# WARNING ABOUT GENERATED CODE
#
# This file is generated. See the contributing guide for more information:
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
#
# WARNING ABOUT GENERATED CODE

module Aws
  module Connect
    class Client < ::Seahorse::Client::Base
      include ::Aws::ClientStubs

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#initialize-instance_method
      def self.new: (
                      ?credentials: untyped,
                      ?region: String,
                      ?access_key_id: String,
                      ?account_id: String,
                      ?active_endpoint_cache: bool,
                      ?adaptive_retry_wait_to_fill: bool,
                      ?client_side_monitoring: bool,
                      ?client_side_monitoring_client_id: String,
                      ?client_side_monitoring_host: String,
                      ?client_side_monitoring_port: Integer,
                      ?client_side_monitoring_publisher: untyped,
                      ?convert_params: bool,
                      ?correct_clock_skew: bool,
                      ?defaults_mode: String,
                      ?disable_host_prefix_injection: bool,
                      ?disable_request_compression: bool,
                      ?endpoint: String,
                      ?endpoint_cache_max_entries: Integer,
                      ?endpoint_cache_max_threads: Integer,
                      ?endpoint_cache_poll_interval: Integer,
                      ?endpoint_discovery: bool,
                      ?ignore_configured_endpoint_urls: bool,
                      ?log_formatter: untyped,
                      ?log_level: Symbol,
                      ?logger: untyped,
                      ?max_attempts: Integer,
                      ?profile: String,
                      ?request_min_compression_size_bytes: Integer,
                      ?retry_backoff: Proc,
                      ?retry_base_delay: Float,
                      ?retry_jitter: (:none | :equal | :full | ^(Integer) -> Integer),
                      ?retry_limit: Integer,
                      ?retry_max_delay: Integer,
                      ?retry_mode: ("legacy" | "standard" | "adaptive"),
                      ?sdk_ua_app_id: String,
                      ?secret_access_key: String,
                      ?session_token: String,
                      ?sigv4a_signing_region_set: Array[String],
                      ?stub_responses: untyped,
                      ?telemetry_provider: Aws::Telemetry::TelemetryProviderBase,
                      ?token_provider: untyped,
                      ?use_dualstack_endpoint: bool,
                      ?use_fips_endpoint: bool,
                      ?validate_params: bool,
                      ?endpoint_provider: untyped,
                      ?http_proxy: String,
                      ?http_open_timeout: (Float | Integer),
                      ?http_read_timeout: (Float | Integer),
                      ?http_idle_timeout: (Float | Integer),
                      ?http_continue_timeout: (Float | Integer),
                      ?ssl_timeout: (Float | Integer | nil),
                      ?http_wire_trace: bool,
                      ?ssl_verify_peer: bool,
                      ?ssl_ca_bundle: String,
                      ?ssl_ca_directory: String,
                      ?ssl_ca_store: String,
                      ?on_chunk_received: Proc,
                      ?on_chunk_sent: Proc,
                      ?raise_response_errors: bool
                    ) -> instance
                  | (?Hash[Symbol, untyped]) -> instance


      interface _ActivateEvaluationFormResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ActivateEvaluationFormResponse]
        def evaluation_form_id: () -> ::String
        def evaluation_form_arn: () -> ::String
        def evaluation_form_version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#activate_evaluation_form-instance_method
      def activate_evaluation_form: (
                                      instance_id: ::String,
                                      evaluation_form_id: ::String,
                                      evaluation_form_version: ::Integer
                                    ) -> _ActivateEvaluationFormResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ActivateEvaluationFormResponseSuccess

      interface _AssociateAnalyticsDataSetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateAnalyticsDataSetResponse]
        def data_set_id: () -> ::String
        def target_account_id: () -> ::String
        def resource_share_id: () -> ::String
        def resource_share_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_analytics_data_set-instance_method
      def associate_analytics_data_set: (
                                          instance_id: ::String,
                                          data_set_id: ::String,
                                          ?target_account_id: ::String
                                        ) -> _AssociateAnalyticsDataSetResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateAnalyticsDataSetResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_approved_origin-instance_method
      def associate_approved_origin: (
                                       instance_id: ::String,
                                       origin: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_bot-instance_method
      def associate_bot: (
                           instance_id: ::String,
                           ?lex_bot: {
                             name: ::String,
                             lex_region: ::String
                           },
                           ?lex_v2_bot: {
                             alias_arn: ::String?
                           }
                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _AssociateDefaultVocabularyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateDefaultVocabularyResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_default_vocabulary-instance_method
      def associate_default_vocabulary: (
                                          instance_id: ::String,
                                          language_code: ("ar-AE" | "de-CH" | "de-DE" | "en-AB" | "en-AU" | "en-GB" | "en-IE" | "en-IN" | "en-US" | "en-WL" | "es-ES" | "es-US" | "fr-CA" | "fr-FR" | "hi-IN" | "it-IT" | "ja-JP" | "ko-KR" | "pt-BR" | "pt-PT" | "zh-CN" | "en-NZ" | "en-ZA" | "ca-ES" | "da-DK" | "fi-FI" | "id-ID" | "ms-MY" | "nl-NL" | "no-NO" | "pl-PL" | "sv-SE" | "tl-PH"),
                                          ?vocabulary_id: ::String
                                        ) -> _AssociateDefaultVocabularyResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateDefaultVocabularyResponseSuccess

      interface _AssociateFlowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateFlowResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_flow-instance_method
      def associate_flow: (
                            instance_id: ::String,
                            resource_id: ::String,
                            flow_id: ::String,
                            resource_type: ("SMS_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR" | "WHATSAPP_MESSAGING_PHONE_NUMBER")
                          ) -> _AssociateFlowResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateFlowResponseSuccess

      interface _AssociateInstanceStorageConfigResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateInstanceStorageConfigResponse]
        def association_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_instance_storage_config-instance_method
      def associate_instance_storage_config: (
                                               instance_id: ::String,
                                               resource_type: ("CHAT_TRANSCRIPTS" | "CALL_RECORDINGS" | "SCHEDULED_REPORTS" | "MEDIA_STREAMS" | "CONTACT_TRACE_RECORDS" | "AGENT_EVENTS" | "REAL_TIME_CONTACT_ANALYSIS_SEGMENTS" | "ATTACHMENTS" | "CONTACT_EVALUATIONS" | "SCREEN_RECORDINGS" | "REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS" | "REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS" | "EMAIL_MESSAGES"),
                                               storage_config: {
                                                 association_id: ::String?,
                                                 storage_type: ("S3" | "KINESIS_VIDEO_STREAM" | "KINESIS_STREAM" | "KINESIS_FIREHOSE"),
                                                 s3_config: {
                                                   bucket_name: ::String,
                                                   bucket_prefix: ::String,
                                                   encryption_config: {
                                                     encryption_type: ("KMS"),
                                                     key_id: ::String
                                                   }?
                                                 }?,
                                                 kinesis_video_stream_config: {
                                                   prefix: ::String,
                                                   retention_period_hours: ::Integer,
                                                   encryption_config: {
                                                     encryption_type: ("KMS"),
                                                     key_id: ::String
                                                   }
                                                 }?,
                                                 kinesis_stream_config: {
                                                   stream_arn: ::String
                                                 }?,
                                                 kinesis_firehose_config: {
                                                   firehose_arn: ::String
                                                 }?
                                               }
                                             ) -> _AssociateInstanceStorageConfigResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateInstanceStorageConfigResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_lambda_function-instance_method
      def associate_lambda_function: (
                                       instance_id: ::String,
                                       function_arn: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_lex_bot-instance_method
      def associate_lex_bot: (
                               instance_id: ::String,
                               lex_bot: {
                                 name: ::String,
                                 lex_region: ::String
                               }
                             ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_phone_number_contact_flow-instance_method
      def associate_phone_number_contact_flow: (
                                                 phone_number_id: ::String,
                                                 instance_id: ::String,
                                                 contact_flow_id: ::String
                                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_queue_quick_connects-instance_method
      def associate_queue_quick_connects: (
                                            instance_id: ::String,
                                            queue_id: ::String,
                                            quick_connect_ids: Array[::String]
                                          ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_routing_profile_queues-instance_method
      def associate_routing_profile_queues: (
                                              instance_id: ::String,
                                              routing_profile_id: ::String,
                                              queue_configs: Array[
                                                {
                                                  queue_reference: {
                                                    queue_id: ::String,
                                                    channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL")
                                                  },
                                                  priority: ::Integer,
                                                  delay: ::Integer
                                                },
                                              ]
                                            ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _AssociateSecurityKeyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateSecurityKeyResponse]
        def association_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_security_key-instance_method
      def associate_security_key: (
                                    instance_id: ::String,
                                    key: ::String
                                  ) -> _AssociateSecurityKeyResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateSecurityKeyResponseSuccess

      interface _AssociateTrafficDistributionGroupUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateTrafficDistributionGroupUserResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_traffic_distribution_group_user-instance_method
      def associate_traffic_distribution_group_user: (
                                                       traffic_distribution_group_id: ::String,
                                                       user_id: ::String,
                                                       instance_id: ::String
                                                     ) -> _AssociateTrafficDistributionGroupUserResponseSuccess
                                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateTrafficDistributionGroupUserResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#associate_user_proficiencies-instance_method
      def associate_user_proficiencies: (
                                          instance_id: ::String,
                                          user_id: ::String,
                                          user_proficiencies: Array[
                                            {
                                              attribute_name: ::String,
                                              attribute_value: ::String,
                                              level: ::Float
                                            },
                                          ]
                                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _BatchAssociateAnalyticsDataSetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchAssociateAnalyticsDataSetResponse]
        def created: () -> ::Array[Types::AnalyticsDataAssociationResult]
        def errors: () -> ::Array[Types::ErrorResult]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#batch_associate_analytics_data_set-instance_method
      def batch_associate_analytics_data_set: (
                                                instance_id: ::String,
                                                data_set_ids: Array[::String],
                                                ?target_account_id: ::String
                                              ) -> _BatchAssociateAnalyticsDataSetResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchAssociateAnalyticsDataSetResponseSuccess

      interface _BatchDisassociateAnalyticsDataSetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchDisassociateAnalyticsDataSetResponse]
        def deleted: () -> ::Array[::String]
        def errors: () -> ::Array[Types::ErrorResult]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#batch_disassociate_analytics_data_set-instance_method
      def batch_disassociate_analytics_data_set: (
                                                   instance_id: ::String,
                                                   data_set_ids: Array[::String],
                                                   ?target_account_id: ::String
                                                 ) -> _BatchDisassociateAnalyticsDataSetResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchDisassociateAnalyticsDataSetResponseSuccess

      interface _BatchGetAttachedFileMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetAttachedFileMetadataResponse]
        def files: () -> ::Array[Types::AttachedFile]
        def errors: () -> ::Array[Types::AttachedFileError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#batch_get_attached_file_metadata-instance_method
      def batch_get_attached_file_metadata: (
                                              file_ids: Array[::String],
                                              instance_id: ::String,
                                              associated_resource_arn: ::String
                                            ) -> _BatchGetAttachedFileMetadataResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetAttachedFileMetadataResponseSuccess

      interface _BatchGetFlowAssociationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetFlowAssociationResponse]
        def flow_association_summary_list: () -> ::Array[Types::FlowAssociationSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#batch_get_flow_association-instance_method
      def batch_get_flow_association: (
                                        instance_id: ::String,
                                        resource_ids: Array[::String],
                                        ?resource_type: ("WHATSAPP_MESSAGING_PHONE_NUMBER" | "VOICE_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR")
                                      ) -> _BatchGetFlowAssociationResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetFlowAssociationResponseSuccess

      interface _BatchPutContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchPutContactResponse]
        def successful_request_list: () -> ::Array[Types::SuccessfulRequest]
        def failed_request_list: () -> ::Array[Types::FailedRequest]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#batch_put_contact-instance_method
      def batch_put_contact: (
                               ?client_token: ::String,
                               instance_id: ::String,
                               contact_data_request_list: Array[
                                 {
                                   system_endpoint: {
                                     type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                                     address: ::String?
                                   }?,
                                   customer_endpoint: {
                                     type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                                     address: ::String?
                                   }?,
                                   request_identifier: ::String?,
                                   queue_id: ::String?,
                                   attributes: Hash[::String, ::String]?,
                                   campaign: {
                                     campaign_id: ::String?
                                   }?
                                 },
                               ]
                             ) -> _BatchPutContactResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchPutContactResponseSuccess

      interface _ClaimPhoneNumberResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ClaimPhoneNumberResponse]
        def phone_number_id: () -> ::String
        def phone_number_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#claim_phone_number-instance_method
      def claim_phone_number: (
                                ?target_arn: ::String,
                                ?instance_id: ::String,
                                phone_number: ::String,
                                ?phone_number_description: ::String,
                                ?tags: Hash[::String, ::String],
                                ?client_token: ::String
                              ) -> _ClaimPhoneNumberResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ClaimPhoneNumberResponseSuccess

      interface _CompleteAttachedFileUploadResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CompleteAttachedFileUploadResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#complete_attached_file_upload-instance_method
      def complete_attached_file_upload: (
                                           instance_id: ::String,
                                           file_id: ::String,
                                           associated_resource_arn: ::String
                                         ) -> _CompleteAttachedFileUploadResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CompleteAttachedFileUploadResponseSuccess

      interface _CreateAgentStatusResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateAgentStatusResponse]
        def agent_status_arn: () -> ::String
        def agent_status_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_agent_status-instance_method
      def create_agent_status: (
                                 instance_id: ::String,
                                 name: ::String,
                                 ?description: ::String,
                                 state: ("ENABLED" | "DISABLED"),
                                 ?display_order: ::Integer,
                                 ?tags: Hash[::String, ::String]
                               ) -> _CreateAgentStatusResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateAgentStatusResponseSuccess

      interface _CreateContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateContactResponse]
        def contact_id: () -> ::String
        def contact_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_contact-instance_method
      def create_contact: (
                            instance_id: ::String,
                            ?client_token: ::String,
                            ?related_contact_id: ::String,
                            ?attributes: Hash[::String, ::String],
                            ?references: Hash[::String, {
                                value: ::String?,
                                type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                arn: ::String?,
                                status_reason: ::String?
                              }],
                            channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL"),
                            initiation_method: ("INBOUND" | "OUTBOUND" | "TRANSFER" | "QUEUE_TRANSFER" | "CALLBACK" | "API" | "DISCONNECT" | "MONITOR" | "EXTERNAL_OUTBOUND" | "WEBRTC_API" | "AGENT_REPLY" | "FLOW"),
                            ?expiry_duration_in_minutes: ::Integer,
                            ?user_info: {
                              user_id: ::String?
                            },
                            ?initiate_as: ("CONNECTED_TO_USER"),
                            ?name: ::String,
                            ?description: ::String,
                            ?segment_attributes: Hash[::String, {
                                value_string: ::String?,
                                value_map: Hash[::String, untyped]?,
                                value_integer: ::Integer?
                              }]
                          ) -> _CreateContactResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateContactResponseSuccess

      interface _CreateContactFlowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateContactFlowResponse]
        def contact_flow_id: () -> ::String
        def contact_flow_arn: () -> ::String
        def flow_content_sha_256: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_contact_flow-instance_method
      def create_contact_flow: (
                                 instance_id: ::String,
                                 name: ::String,
                                 type: ("CONTACT_FLOW" | "CUSTOMER_QUEUE" | "CUSTOMER_HOLD" | "CUSTOMER_WHISPER" | "AGENT_HOLD" | "AGENT_WHISPER" | "OUTBOUND_WHISPER" | "AGENT_TRANSFER" | "QUEUE_TRANSFER"),
                                 ?description: ::String,
                                 content: ::String,
                                 ?status: ("PUBLISHED" | "SAVED"),
                                 ?tags: Hash[::String, ::String]
                               ) -> _CreateContactFlowResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateContactFlowResponseSuccess

      interface _CreateContactFlowModuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateContactFlowModuleResponse]
        def id: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_contact_flow_module-instance_method
      def create_contact_flow_module: (
                                        instance_id: ::String,
                                        name: ::String,
                                        ?description: ::String,
                                        content: ::String,
                                        ?tags: Hash[::String, ::String],
                                        ?client_token: ::String
                                      ) -> _CreateContactFlowModuleResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateContactFlowModuleResponseSuccess

      interface _CreateContactFlowVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateContactFlowVersionResponse]
        def contact_flow_arn: () -> ::String
        def version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_contact_flow_version-instance_method
      def create_contact_flow_version: (
                                         instance_id: ::String,
                                         ?description: ::String,
                                         contact_flow_id: ::String,
                                         ?flow_content_sha_256: ::String,
                                         ?last_modified_time: ::Time,
                                         ?last_modified_region: ::String
                                       ) -> _CreateContactFlowVersionResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateContactFlowVersionResponseSuccess

      interface _CreateEmailAddressResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateEmailAddressResponse]
        def email_address_id: () -> ::String
        def email_address_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_email_address-instance_method
      def create_email_address: (
                                  ?description: ::String,
                                  instance_id: ::String,
                                  email_address: ::String,
                                  ?display_name: ::String,
                                  ?tags: Hash[::String, ::String],
                                  ?client_token: ::String
                                ) -> _CreateEmailAddressResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateEmailAddressResponseSuccess

      interface _CreateEvaluationFormResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateEvaluationFormResponse]
        def evaluation_form_id: () -> ::String
        def evaluation_form_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_evaluation_form-instance_method
      def create_evaluation_form: (
                                    instance_id: ::String,
                                    title: ::String,
                                    ?description: ::String,
                                    items: Array[
                                      {
                                        section: {
                                          title: ::String,
                                          ref_id: ::String,
                                          instructions: ::String?,
                                          items: untyped,
                                          weight: ::Float?
                                        }?,
                                        question: {
                                          title: ::String,
                                          instructions: ::String?,
                                          ref_id: ::String,
                                          not_applicable_enabled: bool?,
                                          question_type: ("TEXT" | "SINGLESELECT" | "NUMERIC"),
                                          question_type_properties: {
                                            numeric: {
                                              min_value: ::Integer,
                                              max_value: ::Integer,
                                              options: Array[
                                                {
                                                  min_value: ::Integer,
                                                  max_value: ::Integer,
                                                  score: ::Integer?,
                                                  automatic_fail: bool?
                                                },
                                              ]?,
                                              automation: {
                                                property_value: {
                                                  label: ("OVERALL_CUSTOMER_SENTIMENT_SCORE" | "OVERALL_AGENT_SENTIMENT_SCORE" | "NON_TALK_TIME" | "NON_TALK_TIME_PERCENTAGE" | "NUMBER_OF_INTERRUPTIONS" | "CONTACT_DURATION" | "AGENT_INTERACTION_DURATION" | "CUSTOMER_HOLD_TIME")
                                                }?
                                              }?
                                            }?,
                                            single_select: {
                                              options: Array[
                                                {
                                                  ref_id: ::String,
                                                  text: ::String,
                                                  score: ::Integer?,
                                                  automatic_fail: bool?
                                                },
                                              ],
                                              display_as: ("DROPDOWN" | "RADIO")?,
                                              automation: {
                                                options: Array[
                                                  {
                                                    rule_category: {
                                                      category: ::String,
                                                      condition: ("PRESENT" | "NOT_PRESENT"),
                                                      option_ref_id: ::String
                                                    }?
                                                  },
                                                ],
                                                default_option_ref_id: ::String?
                                              }?
                                            }?
                                          }?,
                                          weight: ::Float?
                                        }?
                                      },
                                    ],
                                    ?scoring_strategy: {
                                      mode: ("QUESTION_ONLY" | "SECTION_ONLY"),
                                      status: ("ENABLED" | "DISABLED")
                                    },
                                    ?client_token: ::String
                                  ) -> _CreateEvaluationFormResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateEvaluationFormResponseSuccess

      interface _CreateHoursOfOperationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateHoursOfOperationResponse]
        def hours_of_operation_id: () -> ::String
        def hours_of_operation_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_hours_of_operation-instance_method
      def create_hours_of_operation: (
                                       instance_id: ::String,
                                       name: ::String,
                                       ?description: ::String,
                                       time_zone: ::String,
                                       config: Array[
                                         {
                                           day: ("SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY"),
                                           start_time: {
                                             hours: ::Integer,
                                             minutes: ::Integer
                                           },
                                           end_time: {
                                             hours: ::Integer,
                                             minutes: ::Integer
                                           }
                                         },
                                       ],
                                       ?tags: Hash[::String, ::String]
                                     ) -> _CreateHoursOfOperationResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateHoursOfOperationResponseSuccess

      interface _CreateHoursOfOperationOverrideResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateHoursOfOperationOverrideResponse]
        def hours_of_operation_override_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_hours_of_operation_override-instance_method
      def create_hours_of_operation_override: (
                                                instance_id: ::String,
                                                hours_of_operation_id: ::String,
                                                name: ::String,
                                                ?description: ::String,
                                                config: Array[
                                                  {
                                                    day: ("SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY")?,
                                                    start_time: {
                                                      hours: ::Integer,
                                                      minutes: ::Integer
                                                    }?,
                                                    end_time: {
                                                      hours: ::Integer,
                                                      minutes: ::Integer
                                                    }?
                                                  },
                                                ],
                                                effective_from: ::String,
                                                effective_till: ::String
                                              ) -> _CreateHoursOfOperationOverrideResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateHoursOfOperationOverrideResponseSuccess

      interface _CreateInstanceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateInstanceResponse]
        def id: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_instance-instance_method
      def create_instance: (
                             ?client_token: ::String,
                             identity_management_type: ("SAML" | "CONNECT_MANAGED" | "EXISTING_DIRECTORY"),
                             ?instance_alias: ::String,
                             ?directory_id: ::String,
                             inbound_calls_enabled: bool,
                             outbound_calls_enabled: bool,
                             ?tags: Hash[::String, ::String]
                           ) -> _CreateInstanceResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateInstanceResponseSuccess

      interface _CreateIntegrationAssociationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateIntegrationAssociationResponse]
        def integration_association_id: () -> ::String
        def integration_association_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_integration_association-instance_method
      def create_integration_association: (
                                            instance_id: ::String,
                                            integration_type: ("EVENT" | "VOICE_ID" | "PINPOINT_APP" | "WISDOM_ASSISTANT" | "WISDOM_KNOWLEDGE_BASE" | "WISDOM_QUICK_RESPONSES" | "Q_MESSAGE_TEMPLATES" | "CASES_DOMAIN" | "APPLICATION" | "FILE_SCANNER" | "SES_IDENTITY" | "ANALYTICS_CONNECTOR" | "CALL_TRANSFER_CONNECTOR" | "COGNITO_USER_POOL"),
                                            integration_arn: ::String,
                                            ?source_application_url: ::String,
                                            ?source_application_name: ::String,
                                            ?source_type: ("SALESFORCE" | "ZENDESK" | "CASES"),
                                            ?tags: Hash[::String, ::String]
                                          ) -> _CreateIntegrationAssociationResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateIntegrationAssociationResponseSuccess

      interface _CreateParticipantResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateParticipantResponse]
        def participant_credentials: () -> Types::ParticipantTokenCredentials
        def participant_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_participant-instance_method
      def create_participant: (
                                instance_id: ::String,
                                contact_id: ::String,
                                ?client_token: ::String,
                                participant_details: {
                                  participant_role: ("AGENT" | "CUSTOMER" | "SYSTEM" | "CUSTOM_BOT" | "SUPERVISOR")?,
                                  display_name: ::String?
                                }
                              ) -> _CreateParticipantResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateParticipantResponseSuccess

      interface _CreatePersistentContactAssociationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePersistentContactAssociationResponse]
        def continued_from_contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_persistent_contact_association-instance_method
      def create_persistent_contact_association: (
                                                   instance_id: ::String,
                                                   initial_contact_id: ::String,
                                                   rehydration_type: ("ENTIRE_PAST_SESSION" | "FROM_SEGMENT"),
                                                   source_contact_id: ::String,
                                                   ?client_token: ::String
                                                 ) -> _CreatePersistentContactAssociationResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePersistentContactAssociationResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_predefined_attribute-instance_method
      def create_predefined_attribute: (
                                         instance_id: ::String,
                                         name: ::String,
                                         values: {
                                           string_list: Array[::String]?
                                         }
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _CreatePromptResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePromptResponse]
        def prompt_arn: () -> ::String
        def prompt_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_prompt-instance_method
      def create_prompt: (
                           instance_id: ::String,
                           name: ::String,
                           ?description: ::String,
                           s3_uri: ::String,
                           ?tags: Hash[::String, ::String]
                         ) -> _CreatePromptResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePromptResponseSuccess

      interface _CreatePushNotificationRegistrationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePushNotificationRegistrationResponse]
        def registration_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_push_notification_registration-instance_method
      def create_push_notification_registration: (
                                                   instance_id: ::String,
                                                   ?client_token: ::String,
                                                   pinpoint_app_arn: ::String,
                                                   device_token: ::String,
                                                   device_type: ("GCM" | "APNS" | "APNS_SANDBOX"),
                                                   contact_configuration: {
                                                     contact_id: ::String,
                                                     participant_role: ("AGENT" | "CUSTOMER" | "SYSTEM" | "CUSTOM_BOT" | "SUPERVISOR")?,
                                                     include_raw_message: bool?
                                                   }
                                                 ) -> _CreatePushNotificationRegistrationResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePushNotificationRegistrationResponseSuccess

      interface _CreateQueueResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateQueueResponse]
        def queue_arn: () -> ::String
        def queue_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_queue-instance_method
      def create_queue: (
                          instance_id: ::String,
                          name: ::String,
                          ?description: ::String,
                          ?outbound_caller_config: {
                            outbound_caller_id_name: ::String?,
                            outbound_caller_id_number_id: ::String?,
                            outbound_flow_id: ::String?
                          },
                          ?outbound_email_config: {
                            outbound_email_address_id: ::String?
                          },
                          hours_of_operation_id: ::String,
                          ?max_contacts: ::Integer,
                          ?quick_connect_ids: Array[::String],
                          ?tags: Hash[::String, ::String]
                        ) -> _CreateQueueResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateQueueResponseSuccess

      interface _CreateQuickConnectResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateQuickConnectResponse]
        def quick_connect_arn: () -> ::String
        def quick_connect_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_quick_connect-instance_method
      def create_quick_connect: (
                                  instance_id: ::String,
                                  name: ::String,
                                  ?description: ::String,
                                  quick_connect_config: {
                                    quick_connect_type: ("USER" | "QUEUE" | "PHONE_NUMBER"),
                                    user_config: {
                                      user_id: ::String,
                                      contact_flow_id: ::String
                                    }?,
                                    queue_config: {
                                      queue_id: ::String,
                                      contact_flow_id: ::String
                                    }?,
                                    phone_config: {
                                      phone_number: ::String
                                    }?
                                  },
                                  ?tags: Hash[::String, ::String]
                                ) -> _CreateQuickConnectResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateQuickConnectResponseSuccess

      interface _CreateRoutingProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateRoutingProfileResponse]
        def routing_profile_arn: () -> ::String
        def routing_profile_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_routing_profile-instance_method
      def create_routing_profile: (
                                    instance_id: ::String,
                                    name: ::String,
                                    description: ::String,
                                    default_outbound_queue_id: ::String,
                                    ?queue_configs: Array[
                                      {
                                        queue_reference: {
                                          queue_id: ::String,
                                          channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL")
                                        },
                                        priority: ::Integer,
                                        delay: ::Integer
                                      },
                                    ],
                                    media_concurrencies: Array[
                                      {
                                        channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL"),
                                        concurrency: ::Integer,
                                        cross_channel_behavior: {
                                          behavior_type: ("ROUTE_CURRENT_CHANNEL_ONLY" | "ROUTE_ANY_CHANNEL")
                                        }?
                                      },
                                    ],
                                    ?tags: Hash[::String, ::String],
                                    ?agent_availability_timer: ("TIME_SINCE_LAST_ACTIVITY" | "TIME_SINCE_LAST_INBOUND")
                                  ) -> _CreateRoutingProfileResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateRoutingProfileResponseSuccess

      interface _CreateRuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateRuleResponse]
        def rule_arn: () -> ::String
        def rule_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_rule-instance_method
      def create_rule: (
                         instance_id: ::String,
                         name: ::String,
                         trigger_event_source: {
                           event_source_name: ("OnPostCallAnalysisAvailable" | "OnRealTimeCallAnalysisAvailable" | "OnRealTimeChatAnalysisAvailable" | "OnPostChatAnalysisAvailable" | "OnZendeskTicketCreate" | "OnZendeskTicketStatusUpdate" | "OnSalesforceCaseCreate" | "OnContactEvaluationSubmit" | "OnMetricDataUpdate" | "OnCaseCreate" | "OnCaseUpdate"),
                           integration_association_id: ::String?
                         },
                         function: ::String,
                         actions: Array[
                           {
                             action_type: ("CREATE_TASK" | "ASSIGN_CONTACT_CATEGORY" | "GENERATE_EVENTBRIDGE_EVENT" | "SEND_NOTIFICATION" | "CREATE_CASE" | "UPDATE_CASE" | "END_ASSOCIATED_TASKS" | "SUBMIT_AUTO_EVALUATION"),
                             task_action: {
                               name: ::String,
                               description: ::String?,
                               contact_flow_id: ::String,
                               references: Hash[::String, {
                                   value: ::String?,
                                   type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                   status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                   arn: ::String?,
                                   status_reason: ::String?
                                 }]?
                             }?,
                             event_bridge_action: {
                               name: ::String
                             }?,
                             assign_contact_category_action: {
                             }?,
                             send_notification_action: {
                               delivery_method: ("EMAIL"),
                               subject: ::String?,
                               content: ::String,
                               content_type: ("PLAIN_TEXT"),
                               recipient: {
                                 user_tags: Hash[::String, ::String]?,
                                 user_ids: Array[::String]?
                               }
                             }?,
                             create_case_action: {
                               fields: Array[
                                 {
                                   id: ::String,
                                   value: {
                                     boolean_value: bool?,
                                     double_value: ::Float?,
                                     empty_value: {
                                     }?,
                                     string_value: ::String?
                                   }
                                 },
                               ],
                               template_id: ::String
                             }?,
                             update_case_action: {
                               fields: Array[
                                 {
                                   id: ::String,
                                   value: {
                                     boolean_value: bool?,
                                     double_value: ::Float?,
                                     empty_value: {
                                     }?,
                                     string_value: ::String?
                                   }
                                 },
                               ]
                             }?,
                             end_associated_tasks_action: {
                             }?,
                             submit_auto_evaluation_action: {
                               evaluation_form_id: ::String
                             }?
                           },
                         ],
                         publish_status: ("DRAFT" | "PUBLISHED"),
                         ?client_token: ::String
                       ) -> _CreateRuleResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateRuleResponseSuccess

      interface _CreateSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSecurityProfileResponse]
        def security_profile_id: () -> ::String
        def security_profile_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_security_profile-instance_method
      def create_security_profile: (
                                     security_profile_name: ::String,
                                     ?description: ::String,
                                     ?permissions: Array[::String],
                                     instance_id: ::String,
                                     ?tags: Hash[::String, ::String],
                                     ?allowed_access_control_tags: Hash[::String, ::String],
                                     ?tag_restricted_resources: Array[::String],
                                     ?applications: Array[
                                       {
                                         namespace: ::String?,
                                         application_permissions: Array[::String]?
                                       },
                                     ],
                                     ?hierarchy_restricted_resources: Array[::String],
                                     ?allowed_access_control_hierarchy_group_id: ::String
                                   ) -> _CreateSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSecurityProfileResponseSuccess

      interface _CreateTaskTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTaskTemplateResponse]
        def id: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_task_template-instance_method
      def create_task_template: (
                                  instance_id: ::String,
                                  name: ::String,
                                  ?description: ::String,
                                  ?contact_flow_id: ::String,
                                  ?self_assign_flow_id: ::String,
                                  ?constraints: {
                                    required_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?,
                                    read_only_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?,
                                    invisible_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?
                                  },
                                  ?defaults: {
                                    default_field_values: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?,
                                        default_value: ::String?
                                      },
                                    ]?
                                  },
                                  ?status: ("ACTIVE" | "INACTIVE"),
                                  fields: Array[
                                    {
                                      id: {
                                        name: ::String?
                                      },
                                      description: ::String?,
                                      type: ("NAME" | "DESCRIPTION" | "SCHEDULED_TIME" | "QUICK_CONNECT" | "URL" | "NUMBER" | "TEXT" | "TEXT_AREA" | "DATE_TIME" | "BOOLEAN" | "SINGLE_SELECT" | "EMAIL" | "SELF_ASSIGN" | "EXPIRY_DURATION")?,
                                      single_select_options: Array[::String]?
                                    },
                                  ],
                                  ?client_token: ::String
                                ) -> _CreateTaskTemplateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTaskTemplateResponseSuccess

      interface _CreateTrafficDistributionGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTrafficDistributionGroupResponse]
        def id: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_traffic_distribution_group-instance_method
      def create_traffic_distribution_group: (
                                               name: ::String,
                                               ?description: ::String,
                                               instance_id: ::String,
                                               ?client_token: ::String,
                                               ?tags: Hash[::String, ::String]
                                             ) -> _CreateTrafficDistributionGroupResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTrafficDistributionGroupResponseSuccess

      interface _CreateUseCaseResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateUseCaseResponse]
        def use_case_id: () -> ::String
        def use_case_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_use_case-instance_method
      def create_use_case: (
                             instance_id: ::String,
                             integration_association_id: ::String,
                             use_case_type: ("RULES_EVALUATION" | "CONNECT_CAMPAIGNS"),
                             ?tags: Hash[::String, ::String]
                           ) -> _CreateUseCaseResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUseCaseResponseSuccess

      interface _CreateUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateUserResponse]
        def user_id: () -> ::String
        def user_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_user-instance_method
      def create_user: (
                         username: ::String,
                         ?password: ::String,
                         ?identity_info: {
                           first_name: ::String?,
                           last_name: ::String?,
                           email: ::String?,
                           secondary_email: ::String?,
                           mobile: ::String?
                         },
                         phone_config: {
                           phone_type: ("SOFT_PHONE" | "DESK_PHONE"),
                           auto_accept: bool?,
                           after_contact_work_time_limit: ::Integer?,
                           desk_phone_number: ::String?
                         },
                         ?directory_user_id: ::String,
                         security_profile_ids: Array[::String],
                         routing_profile_id: ::String,
                         ?hierarchy_group_id: ::String,
                         instance_id: ::String,
                         ?tags: Hash[::String, ::String]
                       ) -> _CreateUserResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUserResponseSuccess

      interface _CreateUserHierarchyGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateUserHierarchyGroupResponse]
        def hierarchy_group_id: () -> ::String
        def hierarchy_group_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_user_hierarchy_group-instance_method
      def create_user_hierarchy_group: (
                                         name: ::String,
                                         ?parent_group_id: ::String,
                                         instance_id: ::String,
                                         ?tags: Hash[::String, ::String]
                                       ) -> _CreateUserHierarchyGroupResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUserHierarchyGroupResponseSuccess

      interface _CreateViewResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateViewResponse]
        def view: () -> Types::View
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_view-instance_method
      def create_view: (
                         instance_id: ::String,
                         ?client_token: ::String,
                         status: ("PUBLISHED" | "SAVED"),
                         content: {
                           template: ::String?,
                           actions: Array[::String]?
                         },
                         ?description: ::String,
                         name: ::String,
                         ?tags: Hash[::String, ::String]
                       ) -> _CreateViewResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateViewResponseSuccess

      interface _CreateViewVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateViewVersionResponse]
        def view: () -> Types::View
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_view_version-instance_method
      def create_view_version: (
                                 instance_id: ::String,
                                 view_id: ::String,
                                 ?version_description: ::String,
                                 ?view_content_sha_256: ::String
                               ) -> _CreateViewVersionResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateViewVersionResponseSuccess

      interface _CreateVocabularyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateVocabularyResponse]
        def vocabulary_arn: () -> ::String
        def vocabulary_id: () -> ::String
        def state: () -> ("CREATION_IN_PROGRESS" | "ACTIVE" | "CREATION_FAILED" | "DELETE_IN_PROGRESS")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#create_vocabulary-instance_method
      def create_vocabulary: (
                               ?client_token: ::String,
                               instance_id: ::String,
                               vocabulary_name: ::String,
                               language_code: ("ar-AE" | "de-CH" | "de-DE" | "en-AB" | "en-AU" | "en-GB" | "en-IE" | "en-IN" | "en-US" | "en-WL" | "es-ES" | "es-US" | "fr-CA" | "fr-FR" | "hi-IN" | "it-IT" | "ja-JP" | "ko-KR" | "pt-BR" | "pt-PT" | "zh-CN" | "en-NZ" | "en-ZA" | "ca-ES" | "da-DK" | "fi-FI" | "id-ID" | "ms-MY" | "nl-NL" | "no-NO" | "pl-PL" | "sv-SE" | "tl-PH"),
                               content: ::String,
                               ?tags: Hash[::String, ::String]
                             ) -> _CreateVocabularyResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateVocabularyResponseSuccess

      interface _DeactivateEvaluationFormResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeactivateEvaluationFormResponse]
        def evaluation_form_id: () -> ::String
        def evaluation_form_arn: () -> ::String
        def evaluation_form_version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#deactivate_evaluation_form-instance_method
      def deactivate_evaluation_form: (
                                        instance_id: ::String,
                                        evaluation_form_id: ::String,
                                        evaluation_form_version: ::Integer
                                      ) -> _DeactivateEvaluationFormResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeactivateEvaluationFormResponseSuccess

      interface _DeleteAttachedFileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteAttachedFileResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_attached_file-instance_method
      def delete_attached_file: (
                                  instance_id: ::String,
                                  file_id: ::String,
                                  associated_resource_arn: ::String
                                ) -> _DeleteAttachedFileResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteAttachedFileResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_contact_evaluation-instance_method
      def delete_contact_evaluation: (
                                       instance_id: ::String,
                                       evaluation_id: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeleteContactFlowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteContactFlowResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_contact_flow-instance_method
      def delete_contact_flow: (
                                 instance_id: ::String,
                                 contact_flow_id: ::String
                               ) -> _DeleteContactFlowResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteContactFlowResponseSuccess

      interface _DeleteContactFlowModuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteContactFlowModuleResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_contact_flow_module-instance_method
      def delete_contact_flow_module: (
                                        instance_id: ::String,
                                        contact_flow_module_id: ::String
                                      ) -> _DeleteContactFlowModuleResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteContactFlowModuleResponseSuccess

      interface _DeleteEmailAddressResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteEmailAddressResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_email_address-instance_method
      def delete_email_address: (
                                  instance_id: ::String,
                                  email_address_id: ::String
                                ) -> _DeleteEmailAddressResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteEmailAddressResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_evaluation_form-instance_method
      def delete_evaluation_form: (
                                    instance_id: ::String,
                                    evaluation_form_id: ::String,
                                    ?evaluation_form_version: ::Integer
                                  ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_hours_of_operation-instance_method
      def delete_hours_of_operation: (
                                       instance_id: ::String,
                                       hours_of_operation_id: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_hours_of_operation_override-instance_method
      def delete_hours_of_operation_override: (
                                                instance_id: ::String,
                                                hours_of_operation_id: ::String,
                                                hours_of_operation_override_id: ::String
                                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_instance-instance_method
      def delete_instance: (
                             instance_id: ::String
                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_integration_association-instance_method
      def delete_integration_association: (
                                            instance_id: ::String,
                                            integration_association_id: ::String
                                          ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_predefined_attribute-instance_method
      def delete_predefined_attribute: (
                                         instance_id: ::String,
                                         name: ::String
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_prompt-instance_method
      def delete_prompt: (
                           instance_id: ::String,
                           prompt_id: ::String
                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeletePushNotificationRegistrationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeletePushNotificationRegistrationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_push_notification_registration-instance_method
      def delete_push_notification_registration: (
                                                   instance_id: ::String,
                                                   registration_id: ::String,
                                                   contact_id: ::String
                                                 ) -> _DeletePushNotificationRegistrationResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeletePushNotificationRegistrationResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_queue-instance_method
      def delete_queue: (
                          instance_id: ::String,
                          queue_id: ::String
                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_quick_connect-instance_method
      def delete_quick_connect: (
                                  instance_id: ::String,
                                  quick_connect_id: ::String
                                ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_routing_profile-instance_method
      def delete_routing_profile: (
                                    instance_id: ::String,
                                    routing_profile_id: ::String
                                  ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_rule-instance_method
      def delete_rule: (
                         instance_id: ::String,
                         rule_id: ::String
                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_security_profile-instance_method
      def delete_security_profile: (
                                     instance_id: ::String,
                                     security_profile_id: ::String
                                   ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeleteTaskTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteTaskTemplateResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_task_template-instance_method
      def delete_task_template: (
                                  instance_id: ::String,
                                  task_template_id: ::String
                                ) -> _DeleteTaskTemplateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteTaskTemplateResponseSuccess

      interface _DeleteTrafficDistributionGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteTrafficDistributionGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_traffic_distribution_group-instance_method
      def delete_traffic_distribution_group: (
                                               traffic_distribution_group_id: ::String
                                             ) -> _DeleteTrafficDistributionGroupResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteTrafficDistributionGroupResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_use_case-instance_method
      def delete_use_case: (
                             instance_id: ::String,
                             integration_association_id: ::String,
                             use_case_id: ::String
                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_user-instance_method
      def delete_user: (
                         instance_id: ::String,
                         user_id: ::String
                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_user_hierarchy_group-instance_method
      def delete_user_hierarchy_group: (
                                         hierarchy_group_id: ::String,
                                         instance_id: ::String
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeleteViewResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteViewResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_view-instance_method
      def delete_view: (
                         instance_id: ::String,
                         view_id: ::String
                       ) -> _DeleteViewResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteViewResponseSuccess

      interface _DeleteViewVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteViewVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_view_version-instance_method
      def delete_view_version: (
                                 instance_id: ::String,
                                 view_id: ::String,
                                 view_version: ::Integer
                               ) -> _DeleteViewVersionResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteViewVersionResponseSuccess

      interface _DeleteVocabularyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteVocabularyResponse]
        def vocabulary_arn: () -> ::String
        def vocabulary_id: () -> ::String
        def state: () -> ("CREATION_IN_PROGRESS" | "ACTIVE" | "CREATION_FAILED" | "DELETE_IN_PROGRESS")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#delete_vocabulary-instance_method
      def delete_vocabulary: (
                               instance_id: ::String,
                               vocabulary_id: ::String
                             ) -> _DeleteVocabularyResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteVocabularyResponseSuccess

      interface _DescribeAgentStatusResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAgentStatusResponse]
        def agent_status: () -> Types::AgentStatus
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_agent_status-instance_method
      def describe_agent_status: (
                                   instance_id: ::String,
                                   agent_status_id: ::String
                                 ) -> _DescribeAgentStatusResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAgentStatusResponseSuccess

      interface _DescribeAuthenticationProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuthenticationProfileResponse]
        def authentication_profile: () -> Types::AuthenticationProfile
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_authentication_profile-instance_method
      def describe_authentication_profile: (
                                             authentication_profile_id: ::String,
                                             instance_id: ::String
                                           ) -> _DescribeAuthenticationProfileResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuthenticationProfileResponseSuccess

      interface _DescribeContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeContactResponse]
        def contact: () -> Types::Contact
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_contact-instance_method
      def describe_contact: (
                              instance_id: ::String,
                              contact_id: ::String
                            ) -> _DescribeContactResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeContactResponseSuccess

      interface _DescribeContactEvaluationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeContactEvaluationResponse]
        def evaluation: () -> Types::Evaluation
        def evaluation_form: () -> Types::EvaluationFormContent
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_contact_evaluation-instance_method
      def describe_contact_evaluation: (
                                         instance_id: ::String,
                                         evaluation_id: ::String
                                       ) -> _DescribeContactEvaluationResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeContactEvaluationResponseSuccess

      interface _DescribeContactFlowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeContactFlowResponse]
        def contact_flow: () -> Types::ContactFlow
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_contact_flow-instance_method
      def describe_contact_flow: (
                                   instance_id: ::String,
                                   contact_flow_id: ::String
                                 ) -> _DescribeContactFlowResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeContactFlowResponseSuccess

      interface _DescribeContactFlowModuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeContactFlowModuleResponse]
        def contact_flow_module: () -> Types::ContactFlowModule
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_contact_flow_module-instance_method
      def describe_contact_flow_module: (
                                          instance_id: ::String,
                                          contact_flow_module_id: ::String
                                        ) -> _DescribeContactFlowModuleResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeContactFlowModuleResponseSuccess

      interface _DescribeEmailAddressResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEmailAddressResponse]
        def email_address_id: () -> ::String
        def email_address_arn: () -> ::String
        def email_address: () -> ::String
        def display_name: () -> ::String
        def description: () -> ::String
        def create_timestamp: () -> ::String
        def modified_timestamp: () -> ::String
        def tags: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_email_address-instance_method
      def describe_email_address: (
                                    instance_id: ::String,
                                    email_address_id: ::String
                                  ) -> _DescribeEmailAddressResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEmailAddressResponseSuccess

      interface _DescribeEvaluationFormResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEvaluationFormResponse]
        def evaluation_form: () -> Types::EvaluationForm
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_evaluation_form-instance_method
      def describe_evaluation_form: (
                                      instance_id: ::String,
                                      evaluation_form_id: ::String,
                                      ?evaluation_form_version: ::Integer
                                    ) -> _DescribeEvaluationFormResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEvaluationFormResponseSuccess

      interface _DescribeHoursOfOperationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeHoursOfOperationResponse]
        def hours_of_operation: () -> Types::HoursOfOperation
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_hours_of_operation-instance_method
      def describe_hours_of_operation: (
                                         instance_id: ::String,
                                         hours_of_operation_id: ::String
                                       ) -> _DescribeHoursOfOperationResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeHoursOfOperationResponseSuccess

      interface _DescribeHoursOfOperationOverrideResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeHoursOfOperationOverrideResponse]
        def hours_of_operation_override: () -> Types::HoursOfOperationOverride
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_hours_of_operation_override-instance_method
      def describe_hours_of_operation_override: (
                                                  instance_id: ::String,
                                                  hours_of_operation_id: ::String,
                                                  hours_of_operation_override_id: ::String
                                                ) -> _DescribeHoursOfOperationOverrideResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeHoursOfOperationOverrideResponseSuccess

      interface _DescribeInstanceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeInstanceResponse]
        def instance: () -> Types::Instance
        def replication_configuration: () -> Types::ReplicationConfiguration
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_instance-instance_method
      def describe_instance: (
                               instance_id: ::String
                             ) -> _DescribeInstanceResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeInstanceResponseSuccess

      interface _DescribeInstanceAttributeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeInstanceAttributeResponse]
        def attribute: () -> Types::Attribute
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_instance_attribute-instance_method
      def describe_instance_attribute: (
                                         instance_id: ::String,
                                         attribute_type: ("INBOUND_CALLS" | "OUTBOUND_CALLS" | "CONTACTFLOW_LOGS" | "CONTACT_LENS" | "AUTO_RESOLVE_BEST_VOICES" | "USE_CUSTOM_TTS_VOICES" | "EARLY_MEDIA" | "MULTI_PARTY_CONFERENCE" | "HIGH_VOLUME_OUTBOUND" | "ENHANCED_CONTACT_MONITORING" | "ENHANCED_CHAT_MONITORING" | "MULTI_PARTY_CHAT_CONFERENCE")
                                       ) -> _DescribeInstanceAttributeResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeInstanceAttributeResponseSuccess

      interface _DescribeInstanceStorageConfigResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeInstanceStorageConfigResponse]
        def storage_config: () -> Types::InstanceStorageConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_instance_storage_config-instance_method
      def describe_instance_storage_config: (
                                              instance_id: ::String,
                                              association_id: ::String,
                                              resource_type: ("CHAT_TRANSCRIPTS" | "CALL_RECORDINGS" | "SCHEDULED_REPORTS" | "MEDIA_STREAMS" | "CONTACT_TRACE_RECORDS" | "AGENT_EVENTS" | "REAL_TIME_CONTACT_ANALYSIS_SEGMENTS" | "ATTACHMENTS" | "CONTACT_EVALUATIONS" | "SCREEN_RECORDINGS" | "REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS" | "REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS" | "EMAIL_MESSAGES")
                                            ) -> _DescribeInstanceStorageConfigResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeInstanceStorageConfigResponseSuccess

      interface _DescribePhoneNumberResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribePhoneNumberResponse]
        def claimed_phone_number_summary: () -> Types::ClaimedPhoneNumberSummary
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_phone_number-instance_method
      def describe_phone_number: (
                                   phone_number_id: ::String
                                 ) -> _DescribePhoneNumberResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribePhoneNumberResponseSuccess

      interface _DescribePredefinedAttributeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribePredefinedAttributeResponse]
        def predefined_attribute: () -> Types::PredefinedAttribute
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_predefined_attribute-instance_method
      def describe_predefined_attribute: (
                                           instance_id: ::String,
                                           name: ::String
                                         ) -> _DescribePredefinedAttributeResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribePredefinedAttributeResponseSuccess

      interface _DescribePromptResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribePromptResponse]
        def prompt: () -> Types::Prompt
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_prompt-instance_method
      def describe_prompt: (
                             instance_id: ::String,
                             prompt_id: ::String
                           ) -> _DescribePromptResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribePromptResponseSuccess

      interface _DescribeQueueResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeQueueResponse]
        def queue: () -> Types::Queue
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_queue-instance_method
      def describe_queue: (
                            instance_id: ::String,
                            queue_id: ::String
                          ) -> _DescribeQueueResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeQueueResponseSuccess

      interface _DescribeQuickConnectResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeQuickConnectResponse]
        def quick_connect: () -> Types::QuickConnect
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_quick_connect-instance_method
      def describe_quick_connect: (
                                    instance_id: ::String,
                                    quick_connect_id: ::String
                                  ) -> _DescribeQuickConnectResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeQuickConnectResponseSuccess

      interface _DescribeRoutingProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeRoutingProfileResponse]
        def routing_profile: () -> Types::RoutingProfile
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_routing_profile-instance_method
      def describe_routing_profile: (
                                      instance_id: ::String,
                                      routing_profile_id: ::String
                                    ) -> _DescribeRoutingProfileResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeRoutingProfileResponseSuccess

      interface _DescribeRuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeRuleResponse]
        def rule: () -> Types::Rule
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_rule-instance_method
      def describe_rule: (
                           instance_id: ::String,
                           rule_id: ::String
                         ) -> _DescribeRuleResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeRuleResponseSuccess

      interface _DescribeSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeSecurityProfileResponse]
        def security_profile: () -> Types::SecurityProfile
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_security_profile-instance_method
      def describe_security_profile: (
                                       security_profile_id: ::String,
                                       instance_id: ::String
                                     ) -> _DescribeSecurityProfileResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeSecurityProfileResponseSuccess

      interface _DescribeTrafficDistributionGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeTrafficDistributionGroupResponse]
        def traffic_distribution_group: () -> Types::TrafficDistributionGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_traffic_distribution_group-instance_method
      def describe_traffic_distribution_group: (
                                                 traffic_distribution_group_id: ::String
                                               ) -> _DescribeTrafficDistributionGroupResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeTrafficDistributionGroupResponseSuccess

      interface _DescribeUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeUserResponse]
        def user: () -> Types::User
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_user-instance_method
      def describe_user: (
                           user_id: ::String,
                           instance_id: ::String
                         ) -> _DescribeUserResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUserResponseSuccess

      interface _DescribeUserHierarchyGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeUserHierarchyGroupResponse]
        def hierarchy_group: () -> Types::HierarchyGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_user_hierarchy_group-instance_method
      def describe_user_hierarchy_group: (
                                           hierarchy_group_id: ::String,
                                           instance_id: ::String
                                         ) -> _DescribeUserHierarchyGroupResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUserHierarchyGroupResponseSuccess

      interface _DescribeUserHierarchyStructureResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeUserHierarchyStructureResponse]
        def hierarchy_structure: () -> Types::HierarchyStructure
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_user_hierarchy_structure-instance_method
      def describe_user_hierarchy_structure: (
                                               instance_id: ::String
                                             ) -> _DescribeUserHierarchyStructureResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUserHierarchyStructureResponseSuccess

      interface _DescribeViewResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeViewResponse]
        def view: () -> Types::View
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_view-instance_method
      def describe_view: (
                           instance_id: ::String,
                           view_id: ::String
                         ) -> _DescribeViewResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeViewResponseSuccess

      interface _DescribeVocabularyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeVocabularyResponse]
        def vocabulary: () -> Types::Vocabulary
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#describe_vocabulary-instance_method
      def describe_vocabulary: (
                                 instance_id: ::String,
                                 vocabulary_id: ::String
                               ) -> _DescribeVocabularyResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeVocabularyResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_analytics_data_set-instance_method
      def disassociate_analytics_data_set: (
                                             instance_id: ::String,
                                             data_set_id: ::String,
                                             ?target_account_id: ::String
                                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_approved_origin-instance_method
      def disassociate_approved_origin: (
                                          instance_id: ::String,
                                          origin: ::String
                                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_bot-instance_method
      def disassociate_bot: (
                              instance_id: ::String,
                              ?lex_bot: {
                                name: ::String,
                                lex_region: ::String
                              },
                              ?lex_v2_bot: {
                                alias_arn: ::String?
                              }
                            ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DisassociateFlowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DisassociateFlowResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_flow-instance_method
      def disassociate_flow: (
                               instance_id: ::String,
                               resource_id: ::String,
                               resource_type: ("SMS_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR" | "WHATSAPP_MESSAGING_PHONE_NUMBER")
                             ) -> _DisassociateFlowResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DisassociateFlowResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_instance_storage_config-instance_method
      def disassociate_instance_storage_config: (
                                                  instance_id: ::String,
                                                  association_id: ::String,
                                                  resource_type: ("CHAT_TRANSCRIPTS" | "CALL_RECORDINGS" | "SCHEDULED_REPORTS" | "MEDIA_STREAMS" | "CONTACT_TRACE_RECORDS" | "AGENT_EVENTS" | "REAL_TIME_CONTACT_ANALYSIS_SEGMENTS" | "ATTACHMENTS" | "CONTACT_EVALUATIONS" | "SCREEN_RECORDINGS" | "REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS" | "REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS" | "EMAIL_MESSAGES")
                                                ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_lambda_function-instance_method
      def disassociate_lambda_function: (
                                          instance_id: ::String,
                                          function_arn: ::String
                                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_lex_bot-instance_method
      def disassociate_lex_bot: (
                                  instance_id: ::String,
                                  bot_name: ::String,
                                  lex_region: ::String
                                ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_phone_number_contact_flow-instance_method
      def disassociate_phone_number_contact_flow: (
                                                    phone_number_id: ::String,
                                                    instance_id: ::String
                                                  ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_queue_quick_connects-instance_method
      def disassociate_queue_quick_connects: (
                                               instance_id: ::String,
                                               queue_id: ::String,
                                               quick_connect_ids: Array[::String]
                                             ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_routing_profile_queues-instance_method
      def disassociate_routing_profile_queues: (
                                                 instance_id: ::String,
                                                 routing_profile_id: ::String,
                                                 queue_references: Array[
                                                   {
                                                     queue_id: ::String,
                                                     channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL")
                                                   },
                                                 ]
                                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_security_key-instance_method
      def disassociate_security_key: (
                                       instance_id: ::String,
                                       association_id: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DisassociateTrafficDistributionGroupUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DisassociateTrafficDistributionGroupUserResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_traffic_distribution_group_user-instance_method
      def disassociate_traffic_distribution_group_user: (
                                                          traffic_distribution_group_id: ::String,
                                                          user_id: ::String,
                                                          instance_id: ::String
                                                        ) -> _DisassociateTrafficDistributionGroupUserResponseSuccess
                                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DisassociateTrafficDistributionGroupUserResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#disassociate_user_proficiencies-instance_method
      def disassociate_user_proficiencies: (
                                             instance_id: ::String,
                                             user_id: ::String,
                                             user_proficiencies: Array[
                                               {
                                                 attribute_name: ::String,
                                                 attribute_value: ::String
                                               },
                                             ]
                                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DismissUserContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DismissUserContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#dismiss_user_contact-instance_method
      def dismiss_user_contact: (
                                  user_id: ::String,
                                  instance_id: ::String,
                                  contact_id: ::String
                                ) -> _DismissUserContactResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DismissUserContactResponseSuccess

      interface _GetAttachedFileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetAttachedFileResponse]
        def file_arn: () -> ::String
        def file_id: () -> ::String
        def creation_time: () -> ::String
        def file_status: () -> ("APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")
        def file_name: () -> ::String
        def file_size_in_bytes: () -> ::Integer
        def associated_resource_arn: () -> ::String
        def file_use_case_type: () -> ("EMAIL_MESSAGE" | "ATTACHMENT")
        def created_by: () -> Types::CreatedByInfo
        def download_url_metadata: () -> Types::DownloadUrlMetadata
        def tags: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_attached_file-instance_method
      def get_attached_file: (
                               instance_id: ::String,
                               file_id: ::String,
                               ?url_expiry_in_seconds: ::Integer,
                               associated_resource_arn: ::String
                             ) -> _GetAttachedFileResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetAttachedFileResponseSuccess

      interface _GetContactAttributesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetContactAttributesResponse]
        def attributes: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_contact_attributes-instance_method
      def get_contact_attributes: (
                                    instance_id: ::String,
                                    initial_contact_id: ::String
                                  ) -> _GetContactAttributesResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetContactAttributesResponseSuccess

      interface _GetCurrentMetricDataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCurrentMetricDataResponse]
        def next_token: () -> ::String
        def metric_results: () -> ::Array[Types::CurrentMetricResult]
        def data_snapshot_time: () -> ::Time
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_current_metric_data-instance_method
      def get_current_metric_data: (
                                     instance_id: ::String,
                                     filters: {
                                       queues: Array[::String]?,
                                       channels: Array[("VOICE" | "CHAT" | "TASK" | "EMAIL")]?,
                                       routing_profiles: Array[::String]?,
                                       routing_step_expressions: Array[::String]?
                                     },
                                     ?groupings: Array[("QUEUE" | "CHANNEL" | "ROUTING_PROFILE" | "ROUTING_STEP_EXPRESSION")],
                                     current_metrics: Array[
                                       {
                                         name: ("AGENTS_ONLINE" | "AGENTS_AVAILABLE" | "AGENTS_ON_CALL" | "AGENTS_NON_PRODUCTIVE" | "AGENTS_AFTER_CONTACT_WORK" | "AGENTS_ERROR" | "AGENTS_STAFFED" | "CONTACTS_IN_QUEUE" | "OLDEST_CONTACT_AGE" | "CONTACTS_SCHEDULED" | "AGENTS_ON_CONTACT" | "SLOTS_ACTIVE" | "SLOTS_AVAILABLE")?,
                                         unit: ("SECONDS" | "COUNT" | "PERCENT")?
                                       },
                                     ],
                                     ?next_token: ::String,
                                     ?max_results: ::Integer,
                                     ?sort_criteria: Array[
                                       {
                                         sort_by_metric: ("AGENTS_ONLINE" | "AGENTS_AVAILABLE" | "AGENTS_ON_CALL" | "AGENTS_NON_PRODUCTIVE" | "AGENTS_AFTER_CONTACT_WORK" | "AGENTS_ERROR" | "AGENTS_STAFFED" | "CONTACTS_IN_QUEUE" | "OLDEST_CONTACT_AGE" | "CONTACTS_SCHEDULED" | "AGENTS_ON_CONTACT" | "SLOTS_ACTIVE" | "SLOTS_AVAILABLE")?,
                                         sort_order: ("ASCENDING" | "DESCENDING")?
                                       },
                                     ]
                                   ) -> _GetCurrentMetricDataResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCurrentMetricDataResponseSuccess

      interface _GetCurrentUserDataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCurrentUserDataResponse]
        def next_token: () -> ::String
        def user_data_list: () -> ::Array[Types::UserData]
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_current_user_data-instance_method
      def get_current_user_data: (
                                   instance_id: ::String,
                                   filters: {
                                     queues: Array[::String]?,
                                     contact_filter: {
                                       contact_states: Array[("INCOMING" | "PENDING" | "CONNECTING" | "CONNECTED" | "CONNECTED_ONHOLD" | "MISSED" | "ERROR" | "ENDED" | "REJECTED")]?
                                     }?,
                                     routing_profiles: Array[::String]?,
                                     agents: Array[::String]?,
                                     user_hierarchy_groups: Array[::String]?
                                   },
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _GetCurrentUserDataResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCurrentUserDataResponseSuccess

      interface _GetEffectiveHoursOfOperationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetEffectiveHoursOfOperationsResponse]
        def effective_hours_of_operation_list: () -> ::Array[Types::EffectiveHoursOfOperations]
        def time_zone: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_effective_hours_of_operations-instance_method
      def get_effective_hours_of_operations: (
                                               instance_id: ::String,
                                               hours_of_operation_id: ::String,
                                               from_date: ::String,
                                               to_date: ::String
                                             ) -> _GetEffectiveHoursOfOperationsResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEffectiveHoursOfOperationsResponseSuccess

      interface _GetFederationTokenResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetFederationTokenResponse]
        def credentials: () -> Types::Credentials
        def sign_in_url: () -> ::String
        def user_arn: () -> ::String
        def user_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_federation_token-instance_method
      def get_federation_token: (
                                  instance_id: ::String
                                ) -> _GetFederationTokenResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetFederationTokenResponseSuccess

      interface _GetFlowAssociationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetFlowAssociationResponse]
        def resource_id: () -> ::String
        def flow_id: () -> ::String
        def resource_type: () -> ("SMS_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR" | "WHATSAPP_MESSAGING_PHONE_NUMBER")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_flow_association-instance_method
      def get_flow_association: (
                                  instance_id: ::String,
                                  resource_id: ::String,
                                  resource_type: ("SMS_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR" | "WHATSAPP_MESSAGING_PHONE_NUMBER")
                                ) -> _GetFlowAssociationResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetFlowAssociationResponseSuccess

      interface _GetMetricDataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMetricDataResponse]
        def next_token: () -> ::String
        def metric_results: () -> ::Array[Types::HistoricalMetricResult]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_metric_data-instance_method
      def get_metric_data: (
                             instance_id: ::String,
                             start_time: ::Time,
                             end_time: ::Time,
                             filters: {
                               queues: Array[::String]?,
                               channels: Array[("VOICE" | "CHAT" | "TASK" | "EMAIL")]?,
                               routing_profiles: Array[::String]?,
                               routing_step_expressions: Array[::String]?
                             },
                             ?groupings: Array[("QUEUE" | "CHANNEL" | "ROUTING_PROFILE" | "ROUTING_STEP_EXPRESSION")],
                             historical_metrics: Array[
                               {
                                 name: ("CONTACTS_QUEUED" | "CONTACTS_HANDLED" | "CONTACTS_ABANDONED" | "CONTACTS_CONSULTED" | "CONTACTS_AGENT_HUNG_UP_FIRST" | "CONTACTS_HANDLED_INCOMING" | "CONTACTS_HANDLED_OUTBOUND" | "CONTACTS_HOLD_ABANDONS" | "CONTACTS_TRANSFERRED_IN" | "CONTACTS_TRANSFERRED_OUT" | "CONTACTS_TRANSFERRED_IN_FROM_QUEUE" | "CONTACTS_TRANSFERRED_OUT_FROM_QUEUE" | "CONTACTS_MISSED" | "CALLBACK_CONTACTS_HANDLED" | "API_CONTACTS_HANDLED" | "OCCUPANCY" | "HANDLE_TIME" | "AFTER_CONTACT_WORK_TIME" | "QUEUED_TIME" | "ABANDON_TIME" | "QUEUE_ANSWER_TIME" | "HOLD_TIME" | "INTERACTION_TIME" | "INTERACTION_AND_HOLD_TIME" | "SERVICE_LEVEL")?,
                                 threshold: {
                                   comparison: ("LT")?,
                                   threshold_value: ::Float?
                                 }?,
                                 statistic: ("SUM" | "MAX" | "AVG")?,
                                 unit: ("SECONDS" | "COUNT" | "PERCENT")?
                               },
                             ],
                             ?next_token: ::String,
                             ?max_results: ::Integer
                           ) -> _GetMetricDataResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMetricDataResponseSuccess

      interface _GetMetricDataV2ResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMetricDataV2Response]
        def next_token: () -> ::String
        def metric_results: () -> ::Array[Types::MetricResultV2]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_metric_data_v2-instance_method
      def get_metric_data_v2: (
                                resource_arn: ::String,
                                start_time: ::Time,
                                end_time: ::Time,
                                ?interval: {
                                  time_zone: ::String?,
                                  interval_period: ("FIFTEEN_MIN" | "THIRTY_MIN" | "HOUR" | "DAY" | "WEEK" | "TOTAL")?
                                },
                                filters: Array[
                                  {
                                    filter_key: ::String?,
                                    filter_values: Array[::String]?
                                  },
                                ],
                                ?groupings: Array[::String],
                                metrics: Array[
                                  {
                                    name: ::String?,
                                    threshold: Array[
                                      {
                                        comparison: ::String?,
                                        threshold_value: ::Float?
                                      },
                                    ]?,
                                    metric_filters: Array[
                                      {
                                        metric_filter_key: ::String?,
                                        metric_filter_values: Array[::String]?,
                                        negate: bool?
                                      },
                                    ]?
                                  },
                                ],
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _GetMetricDataV2ResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMetricDataV2ResponseSuccess

      interface _GetPromptFileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPromptFileResponse]
        def prompt_presigned_url: () -> ::String
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_prompt_file-instance_method
      def get_prompt_file: (
                             instance_id: ::String,
                             prompt_id: ::String
                           ) -> _GetPromptFileResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPromptFileResponseSuccess

      interface _GetTaskTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTaskTemplateResponse]
        def instance_id: () -> ::String
        def id: () -> ::String
        def arn: () -> ::String
        def name: () -> ::String
        def description: () -> ::String
        def contact_flow_id: () -> ::String
        def self_assign_flow_id: () -> ::String
        def constraints: () -> Types::TaskTemplateConstraints
        def defaults: () -> Types::TaskTemplateDefaults
        def fields: () -> ::Array[Types::TaskTemplateField]
        def status: () -> ("ACTIVE" | "INACTIVE")
        def last_modified_time: () -> ::Time
        def created_time: () -> ::Time
        def tags: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_task_template-instance_method
      def get_task_template: (
                               instance_id: ::String,
                               task_template_id: ::String,
                               ?snapshot_version: ::String
                             ) -> _GetTaskTemplateResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTaskTemplateResponseSuccess

      interface _GetTrafficDistributionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTrafficDistributionResponse]
        def telephony_config: () -> Types::TelephonyConfig
        def id: () -> ::String
        def arn: () -> ::String
        def sign_in_config: () -> Types::SignInConfig
        def agent_config: () -> Types::AgentConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#get_traffic_distribution-instance_method
      def get_traffic_distribution: (
                                      id: ::String
                                    ) -> _GetTrafficDistributionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTrafficDistributionResponseSuccess

      interface _ImportPhoneNumberResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ImportPhoneNumberResponse]
        def phone_number_id: () -> ::String
        def phone_number_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#import_phone_number-instance_method
      def import_phone_number: (
                                 instance_id: ::String,
                                 source_phone_number_arn: ::String,
                                 ?phone_number_description: ::String,
                                 ?tags: Hash[::String, ::String],
                                 ?client_token: ::String
                               ) -> _ImportPhoneNumberResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ImportPhoneNumberResponseSuccess

      interface _ListAgentStatusesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAgentStatusResponse]
        def next_token: () -> ::String
        def agent_status_summary_list: () -> ::Array[Types::AgentStatusSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_agent_statuses-instance_method
      def list_agent_statuses: (
                                 instance_id: ::String,
                                 ?next_token: ::String,
                                 ?max_results: ::Integer,
                                 ?agent_status_types: Array[("ROUTABLE" | "CUSTOM" | "OFFLINE")]
                               ) -> _ListAgentStatusesResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAgentStatusesResponseSuccess

      interface _ListAnalyticsDataAssociationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAnalyticsDataAssociationsResponse]
        def results: () -> ::Array[Types::AnalyticsDataAssociationResult]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_analytics_data_associations-instance_method
      def list_analytics_data_associations: (
                                              instance_id: ::String,
                                              ?data_set_id: ::String,
                                              ?next_token: ::String,
                                              ?max_results: ::Integer
                                            ) -> _ListAnalyticsDataAssociationsResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAnalyticsDataAssociationsResponseSuccess

      interface _ListApprovedOriginsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListApprovedOriginsResponse]
        def origins: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_approved_origins-instance_method
      def list_approved_origins: (
                                   instance_id: ::String,
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _ListApprovedOriginsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListApprovedOriginsResponseSuccess

      interface _ListAssociatedContactsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAssociatedContactsResponse]
        def contact_summary_list: () -> ::Array[Types::AssociatedContactSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_associated_contacts-instance_method
      def list_associated_contacts: (
                                      instance_id: ::String,
                                      contact_id: ::String,
                                      ?max_results: ::Integer,
                                      ?next_token: ::String
                                    ) -> _ListAssociatedContactsResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAssociatedContactsResponseSuccess

      interface _ListAuthenticationProfilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuthenticationProfilesResponse]
        def authentication_profile_summary_list: () -> ::Array[Types::AuthenticationProfileSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_authentication_profiles-instance_method
      def list_authentication_profiles: (
                                          instance_id: ::String,
                                          ?max_results: ::Integer,
                                          ?next_token: ::String
                                        ) -> _ListAuthenticationProfilesResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuthenticationProfilesResponseSuccess

      interface _ListBotsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListBotsResponse]
        def lex_bots: () -> ::Array[Types::LexBotConfig]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_bots-instance_method
      def list_bots: (
                       instance_id: ::String,
                       ?next_token: ::String,
                       ?max_results: ::Integer,
                       lex_version: ("V1" | "V2")
                     ) -> _ListBotsResponseSuccess
                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListBotsResponseSuccess

      interface _ListContactEvaluationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListContactEvaluationsResponse]
        def evaluation_summary_list: () -> ::Array[Types::EvaluationSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_contact_evaluations-instance_method
      def list_contact_evaluations: (
                                      instance_id: ::String,
                                      contact_id: ::String,
                                      ?next_token: ::String
                                    ) -> _ListContactEvaluationsResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListContactEvaluationsResponseSuccess

      interface _ListContactFlowModulesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListContactFlowModulesResponse]
        def contact_flow_modules_summary_list: () -> ::Array[Types::ContactFlowModuleSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_contact_flow_modules-instance_method
      def list_contact_flow_modules: (
                                       instance_id: ::String,
                                       ?next_token: ::String,
                                       ?max_results: ::Integer,
                                       ?contact_flow_module_state: ("ACTIVE" | "ARCHIVED")
                                     ) -> _ListContactFlowModulesResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListContactFlowModulesResponseSuccess

      interface _ListContactFlowVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListContactFlowVersionsResponse]
        def contact_flow_version_summary_list: () -> ::Array[Types::ContactFlowVersionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_contact_flow_versions-instance_method
      def list_contact_flow_versions: (
                                        instance_id: ::String,
                                        contact_flow_id: ::String,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer
                                      ) -> _ListContactFlowVersionsResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListContactFlowVersionsResponseSuccess

      interface _ListContactFlowsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListContactFlowsResponse]
        def contact_flow_summary_list: () -> ::Array[Types::ContactFlowSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_contact_flows-instance_method
      def list_contact_flows: (
                                instance_id: ::String,
                                ?contact_flow_types: Array[("CONTACT_FLOW" | "CUSTOMER_QUEUE" | "CUSTOMER_HOLD" | "CUSTOMER_WHISPER" | "AGENT_HOLD" | "AGENT_WHISPER" | "OUTBOUND_WHISPER" | "AGENT_TRANSFER" | "QUEUE_TRANSFER")],
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _ListContactFlowsResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListContactFlowsResponseSuccess

      interface _ListContactReferencesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListContactReferencesResponse]
        def reference_summary_list: () -> ::Array[Types::ReferenceSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_contact_references-instance_method
      def list_contact_references: (
                                     instance_id: ::String,
                                     contact_id: ::String,
                                     reference_types: Array[("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE")],
                                     ?next_token: ::String
                                   ) -> _ListContactReferencesResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListContactReferencesResponseSuccess

      interface _ListDefaultVocabulariesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDefaultVocabulariesResponse]
        def default_vocabulary_list: () -> ::Array[Types::DefaultVocabulary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_default_vocabularies-instance_method
      def list_default_vocabularies: (
                                       instance_id: ::String,
                                       ?language_code: ("ar-AE" | "de-CH" | "de-DE" | "en-AB" | "en-AU" | "en-GB" | "en-IE" | "en-IN" | "en-US" | "en-WL" | "es-ES" | "es-US" | "fr-CA" | "fr-FR" | "hi-IN" | "it-IT" | "ja-JP" | "ko-KR" | "pt-BR" | "pt-PT" | "zh-CN" | "en-NZ" | "en-ZA" | "ca-ES" | "da-DK" | "fi-FI" | "id-ID" | "ms-MY" | "nl-NL" | "no-NO" | "pl-PL" | "sv-SE" | "tl-PH"),
                                       ?max_results: ::Integer,
                                       ?next_token: ::String
                                     ) -> _ListDefaultVocabulariesResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDefaultVocabulariesResponseSuccess

      interface _ListEvaluationFormVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListEvaluationFormVersionsResponse]
        def evaluation_form_version_summary_list: () -> ::Array[Types::EvaluationFormVersionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_evaluation_form_versions-instance_method
      def list_evaluation_form_versions: (
                                           instance_id: ::String,
                                           evaluation_form_id: ::String,
                                           ?max_results: ::Integer,
                                           ?next_token: ::String
                                         ) -> _ListEvaluationFormVersionsResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListEvaluationFormVersionsResponseSuccess

      interface _ListEvaluationFormsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListEvaluationFormsResponse]
        def evaluation_form_summary_list: () -> ::Array[Types::EvaluationFormSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_evaluation_forms-instance_method
      def list_evaluation_forms: (
                                   instance_id: ::String,
                                   ?max_results: ::Integer,
                                   ?next_token: ::String
                                 ) -> _ListEvaluationFormsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListEvaluationFormsResponseSuccess

      interface _ListFlowAssociationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListFlowAssociationsResponse]
        def flow_association_summary_list: () -> ::Array[Types::FlowAssociationSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_flow_associations-instance_method
      def list_flow_associations: (
                                    instance_id: ::String,
                                    ?resource_type: ("WHATSAPP_MESSAGING_PHONE_NUMBER" | "VOICE_PHONE_NUMBER" | "INBOUND_EMAIL" | "OUTBOUND_EMAIL" | "ANALYTICS_CONNECTOR"),
                                    ?next_token: ::String,
                                    ?max_results: ::Integer
                                  ) -> _ListFlowAssociationsResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListFlowAssociationsResponseSuccess

      interface _ListHoursOfOperationOverridesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListHoursOfOperationOverridesResponse]
        def next_token: () -> ::String
        def hours_of_operation_override_list: () -> ::Array[Types::HoursOfOperationOverride]
        def last_modified_region: () -> ::String
        def last_modified_time: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_hours_of_operation_overrides-instance_method
      def list_hours_of_operation_overrides: (
                                               instance_id: ::String,
                                               hours_of_operation_id: ::String,
                                               ?next_token: ::String,
                                               ?max_results: ::Integer
                                             ) -> _ListHoursOfOperationOverridesResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListHoursOfOperationOverridesResponseSuccess

      interface _ListHoursOfOperationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListHoursOfOperationsResponse]
        def hours_of_operation_summary_list: () -> ::Array[Types::HoursOfOperationSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_hours_of_operations-instance_method
      def list_hours_of_operations: (
                                      instance_id: ::String,
                                      ?next_token: ::String,
                                      ?max_results: ::Integer
                                    ) -> _ListHoursOfOperationsResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListHoursOfOperationsResponseSuccess

      interface _ListInstanceAttributesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListInstanceAttributesResponse]
        def attributes: () -> ::Array[Types::Attribute]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_instance_attributes-instance_method
      def list_instance_attributes: (
                                      instance_id: ::String,
                                      ?next_token: ::String,
                                      ?max_results: ::Integer
                                    ) -> _ListInstanceAttributesResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListInstanceAttributesResponseSuccess

      interface _ListInstanceStorageConfigsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListInstanceStorageConfigsResponse]
        def storage_configs: () -> ::Array[Types::InstanceStorageConfig]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_instance_storage_configs-instance_method
      def list_instance_storage_configs: (
                                           instance_id: ::String,
                                           resource_type: ("CHAT_TRANSCRIPTS" | "CALL_RECORDINGS" | "SCHEDULED_REPORTS" | "MEDIA_STREAMS" | "CONTACT_TRACE_RECORDS" | "AGENT_EVENTS" | "REAL_TIME_CONTACT_ANALYSIS_SEGMENTS" | "ATTACHMENTS" | "CONTACT_EVALUATIONS" | "SCREEN_RECORDINGS" | "REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS" | "REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS" | "EMAIL_MESSAGES"),
                                           ?next_token: ::String,
                                           ?max_results: ::Integer
                                         ) -> _ListInstanceStorageConfigsResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListInstanceStorageConfigsResponseSuccess

      interface _ListInstancesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListInstancesResponse]
        def instance_summary_list: () -> ::Array[Types::InstanceSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_instances-instance_method
      def list_instances: (
                            ?next_token: ::String,
                            ?max_results: ::Integer
                          ) -> _ListInstancesResponseSuccess
                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListInstancesResponseSuccess

      interface _ListIntegrationAssociationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListIntegrationAssociationsResponse]
        def integration_association_summary_list: () -> ::Array[Types::IntegrationAssociationSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_integration_associations-instance_method
      def list_integration_associations: (
                                           instance_id: ::String,
                                           ?integration_type: ("EVENT" | "VOICE_ID" | "PINPOINT_APP" | "WISDOM_ASSISTANT" | "WISDOM_KNOWLEDGE_BASE" | "WISDOM_QUICK_RESPONSES" | "Q_MESSAGE_TEMPLATES" | "CASES_DOMAIN" | "APPLICATION" | "FILE_SCANNER" | "SES_IDENTITY" | "ANALYTICS_CONNECTOR" | "CALL_TRANSFER_CONNECTOR" | "COGNITO_USER_POOL"),
                                           ?next_token: ::String,
                                           ?max_results: ::Integer,
                                           ?integration_arn: ::String
                                         ) -> _ListIntegrationAssociationsResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListIntegrationAssociationsResponseSuccess

      interface _ListLambdaFunctionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListLambdaFunctionsResponse]
        def lambda_functions: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_lambda_functions-instance_method
      def list_lambda_functions: (
                                   instance_id: ::String,
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _ListLambdaFunctionsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListLambdaFunctionsResponseSuccess

      interface _ListLexBotsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListLexBotsResponse]
        def lex_bots: () -> ::Array[Types::LexBot]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_lex_bots-instance_method
      def list_lex_bots: (
                           instance_id: ::String,
                           ?next_token: ::String,
                           ?max_results: ::Integer
                         ) -> _ListLexBotsResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListLexBotsResponseSuccess

      interface _ListPhoneNumbersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPhoneNumbersResponse]
        def phone_number_summary_list: () -> ::Array[Types::PhoneNumberSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_phone_numbers-instance_method
      def list_phone_numbers: (
                                instance_id: ::String,
                                ?phone_number_types: Array[("TOLL_FREE" | "DID" | "UIFN" | "SHARED" | "THIRD_PARTY_TF" | "THIRD_PARTY_DID" | "SHORT_CODE")],
                                ?phone_number_country_codes: Array[("AF" | "AL" | "DZ" | "AS" | "AD" | "AO" | "AI" | "AQ" | "AG" | "AR" | "AM" | "AW" | "AU" | "AT" | "AZ" | "BS" | "BH" | "BD" | "BB" | "BY" | "BE" | "BZ" | "BJ" | "BM" | "BT" | "BO" | "BA" | "BW" | "BR" | "IO" | "VG" | "BN" | "BG" | "BF" | "BI" | "KH" | "CM" | "CA" | "CV" | "KY" | "CF" | "TD" | "CL" | "CN" | "CX" | "CC" | "CO" | "KM" | "CK" | "CR" | "HR" | "CU" | "CW" | "CY" | "CZ" | "CD" | "DK" | "DJ" | "DM" | "DO" | "TL" | "EC" | "EG" | "SV" | "GQ" | "ER" | "EE" | "ET" | "FK" | "FO" | "FJ" | "FI" | "FR" | "PF" | "GA" | "GM" | "GE" | "DE" | "GH" | "GI" | "GR" | "GL" | "GD" | "GU" | "GT" | "GG" | "GN" | "GW" | "GY" | "HT" | "HN" | "HK" | "HU" | "IS" | "IN" | "ID" | "IR" | "IQ" | "IE" | "IM" | "IL" | "IT" | "CI" | "JM" | "JP" | "JE" | "JO" | "KZ" | "KE" | "KI" | "KW" | "KG" | "LA" | "LV" | "LB" | "LS" | "LR" | "LY" | "LI" | "LT" | "LU" | "MO" | "MK" | "MG" | "MW" | "MY" | "MV" | "ML" | "MT" | "MH" | "MR" | "MU" | "YT" | "MX" | "FM" | "MD" | "MC" | "MN" | "ME" | "MS" | "MA" | "MZ" | "MM" | "NA" | "NR" | "NP" | "NL" | "AN" | "NC" | "NZ" | "NI" | "NE" | "NG" | "NU" | "KP" | "MP" | "NO" | "OM" | "PK" | "PW" | "PA" | "PG" | "PY" | "PE" | "PH" | "PN" | "PL" | "PT" | "PR" | "QA" | "CG" | "RE" | "RO" | "RU" | "RW" | "BL" | "SH" | "KN" | "LC" | "MF" | "PM" | "VC" | "WS" | "SM" | "ST" | "SA" | "SN" | "RS" | "SC" | "SL" | "SG" | "SX" | "SK" | "SI" | "SB" | "SO" | "ZA" | "KR" | "ES" | "LK" | "SD" | "SR" | "SJ" | "SZ" | "SE" | "CH" | "SY" | "TW" | "TJ" | "TZ" | "TH" | "TG" | "TK" | "TO" | "TT" | "TN" | "TR" | "TM" | "TC" | "TV" | "VI" | "UG" | "UA" | "AE" | "GB" | "US" | "UY" | "UZ" | "VU" | "VA" | "VE" | "VN" | "WF" | "EH" | "YE" | "ZM" | "ZW")],
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _ListPhoneNumbersResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPhoneNumbersResponseSuccess

      interface _ListPhoneNumbersV2ResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPhoneNumbersV2Response]
        def next_token: () -> ::String
        def list_phone_numbers_summary_list: () -> ::Array[Types::ListPhoneNumbersSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_phone_numbers_v2-instance_method
      def list_phone_numbers_v2: (
                                   ?target_arn: ::String,
                                   ?instance_id: ::String,
                                   ?max_results: ::Integer,
                                   ?next_token: ::String,
                                   ?phone_number_country_codes: Array[("AF" | "AL" | "DZ" | "AS" | "AD" | "AO" | "AI" | "AQ" | "AG" | "AR" | "AM" | "AW" | "AU" | "AT" | "AZ" | "BS" | "BH" | "BD" | "BB" | "BY" | "BE" | "BZ" | "BJ" | "BM" | "BT" | "BO" | "BA" | "BW" | "BR" | "IO" | "VG" | "BN" | "BG" | "BF" | "BI" | "KH" | "CM" | "CA" | "CV" | "KY" | "CF" | "TD" | "CL" | "CN" | "CX" | "CC" | "CO" | "KM" | "CK" | "CR" | "HR" | "CU" | "CW" | "CY" | "CZ" | "CD" | "DK" | "DJ" | "DM" | "DO" | "TL" | "EC" | "EG" | "SV" | "GQ" | "ER" | "EE" | "ET" | "FK" | "FO" | "FJ" | "FI" | "FR" | "PF" | "GA" | "GM" | "GE" | "DE" | "GH" | "GI" | "GR" | "GL" | "GD" | "GU" | "GT" | "GG" | "GN" | "GW" | "GY" | "HT" | "HN" | "HK" | "HU" | "IS" | "IN" | "ID" | "IR" | "IQ" | "IE" | "IM" | "IL" | "IT" | "CI" | "JM" | "JP" | "JE" | "JO" | "KZ" | "KE" | "KI" | "KW" | "KG" | "LA" | "LV" | "LB" | "LS" | "LR" | "LY" | "LI" | "LT" | "LU" | "MO" | "MK" | "MG" | "MW" | "MY" | "MV" | "ML" | "MT" | "MH" | "MR" | "MU" | "YT" | "MX" | "FM" | "MD" | "MC" | "MN" | "ME" | "MS" | "MA" | "MZ" | "MM" | "NA" | "NR" | "NP" | "NL" | "AN" | "NC" | "NZ" | "NI" | "NE" | "NG" | "NU" | "KP" | "MP" | "NO" | "OM" | "PK" | "PW" | "PA" | "PG" | "PY" | "PE" | "PH" | "PN" | "PL" | "PT" | "PR" | "QA" | "CG" | "RE" | "RO" | "RU" | "RW" | "BL" | "SH" | "KN" | "LC" | "MF" | "PM" | "VC" | "WS" | "SM" | "ST" | "SA" | "SN" | "RS" | "SC" | "SL" | "SG" | "SX" | "SK" | "SI" | "SB" | "SO" | "ZA" | "KR" | "ES" | "LK" | "SD" | "SR" | "SJ" | "SZ" | "SE" | "CH" | "SY" | "TW" | "TJ" | "TZ" | "TH" | "TG" | "TK" | "TO" | "TT" | "TN" | "TR" | "TM" | "TC" | "TV" | "VI" | "UG" | "UA" | "AE" | "GB" | "US" | "UY" | "UZ" | "VU" | "VA" | "VE" | "VN" | "WF" | "EH" | "YE" | "ZM" | "ZW")],
                                   ?phone_number_types: Array[("TOLL_FREE" | "DID" | "UIFN" | "SHARED" | "THIRD_PARTY_TF" | "THIRD_PARTY_DID" | "SHORT_CODE")],
                                   ?phone_number_prefix: ::String
                                 ) -> _ListPhoneNumbersV2ResponseSuccess
                               | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPhoneNumbersV2ResponseSuccess

      interface _ListPredefinedAttributesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPredefinedAttributesResponse]
        def next_token: () -> ::String
        def predefined_attribute_summary_list: () -> ::Array[Types::PredefinedAttributeSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_predefined_attributes-instance_method
      def list_predefined_attributes: (
                                        instance_id: ::String,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer
                                      ) -> _ListPredefinedAttributesResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPredefinedAttributesResponseSuccess

      interface _ListPromptsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPromptsResponse]
        def prompt_summary_list: () -> ::Array[Types::PromptSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_prompts-instance_method
      def list_prompts: (
                          instance_id: ::String,
                          ?next_token: ::String,
                          ?max_results: ::Integer
                        ) -> _ListPromptsResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPromptsResponseSuccess

      interface _ListQueueQuickConnectsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListQueueQuickConnectsResponse]
        def next_token: () -> ::String
        def quick_connect_summary_list: () -> ::Array[Types::QuickConnectSummary]
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_queue_quick_connects-instance_method
      def list_queue_quick_connects: (
                                       instance_id: ::String,
                                       queue_id: ::String,
                                       ?next_token: ::String,
                                       ?max_results: ::Integer
                                     ) -> _ListQueueQuickConnectsResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListQueueQuickConnectsResponseSuccess

      interface _ListQueuesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListQueuesResponse]
        def queue_summary_list: () -> ::Array[Types::QueueSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_queues-instance_method
      def list_queues: (
                         instance_id: ::String,
                         ?queue_types: Array[("STANDARD" | "AGENT")],
                         ?next_token: ::String,
                         ?max_results: ::Integer
                       ) -> _ListQueuesResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListQueuesResponseSuccess

      interface _ListQuickConnectsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListQuickConnectsResponse]
        def quick_connect_summary_list: () -> ::Array[Types::QuickConnectSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_quick_connects-instance_method
      def list_quick_connects: (
                                 instance_id: ::String,
                                 ?next_token: ::String,
                                 ?max_results: ::Integer,
                                 ?quick_connect_types: Array[("USER" | "QUEUE" | "PHONE_NUMBER")]
                               ) -> _ListQuickConnectsResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListQuickConnectsResponseSuccess

      interface _ListRealtimeContactAnalysisSegmentsV2ResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRealtimeContactAnalysisSegmentsV2Response]
        def channel: () -> ("VOICE" | "CHAT")
        def status: () -> ("IN_PROGRESS" | "FAILED" | "COMPLETED")
        def segments: () -> ::Array[Types::RealtimeContactAnalysisSegment]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_realtime_contact_analysis_segments_v2-instance_method
      def list_realtime_contact_analysis_segments_v2: (
                                                        instance_id: ::String,
                                                        contact_id: ::String,
                                                        ?max_results: ::Integer,
                                                        ?next_token: ::String,
                                                        output_type: ("Raw" | "Redacted"),
                                                        segment_types: Array[("Transcript" | "Categories" | "Issues" | "Event" | "Attachments" | "PostContactSummary")]
                                                      ) -> _ListRealtimeContactAnalysisSegmentsV2ResponseSuccess
                                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRealtimeContactAnalysisSegmentsV2ResponseSuccess

      interface _ListRoutingProfileQueuesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRoutingProfileQueuesResponse]
        def next_token: () -> ::String
        def routing_profile_queue_config_summary_list: () -> ::Array[Types::RoutingProfileQueueConfigSummary]
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_routing_profile_queues-instance_method
      def list_routing_profile_queues: (
                                         instance_id: ::String,
                                         routing_profile_id: ::String,
                                         ?next_token: ::String,
                                         ?max_results: ::Integer
                                       ) -> _ListRoutingProfileQueuesResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRoutingProfileQueuesResponseSuccess

      interface _ListRoutingProfilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRoutingProfilesResponse]
        def routing_profile_summary_list: () -> ::Array[Types::RoutingProfileSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_routing_profiles-instance_method
      def list_routing_profiles: (
                                   instance_id: ::String,
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _ListRoutingProfilesResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRoutingProfilesResponseSuccess

      interface _ListRulesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRulesResponse]
        def rule_summary_list: () -> ::Array[Types::RuleSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_rules-instance_method
      def list_rules: (
                        instance_id: ::String,
                        ?publish_status: ("DRAFT" | "PUBLISHED"),
                        ?event_source_name: ("OnPostCallAnalysisAvailable" | "OnRealTimeCallAnalysisAvailable" | "OnRealTimeChatAnalysisAvailable" | "OnPostChatAnalysisAvailable" | "OnZendeskTicketCreate" | "OnZendeskTicketStatusUpdate" | "OnSalesforceCaseCreate" | "OnContactEvaluationSubmit" | "OnMetricDataUpdate" | "OnCaseCreate" | "OnCaseUpdate"),
                        ?max_results: ::Integer,
                        ?next_token: ::String
                      ) -> _ListRulesResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRulesResponseSuccess

      interface _ListSecurityKeysResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSecurityKeysResponse]
        def security_keys: () -> ::Array[Types::SecurityKey]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_security_keys-instance_method
      def list_security_keys: (
                                instance_id: ::String,
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _ListSecurityKeysResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSecurityKeysResponseSuccess

      interface _ListSecurityProfileApplicationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSecurityProfileApplicationsResponse]
        def applications: () -> ::Array[Types::Application]
        def next_token: () -> ::String
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_security_profile_applications-instance_method
      def list_security_profile_applications: (
                                                security_profile_id: ::String,
                                                instance_id: ::String,
                                                ?next_token: ::String,
                                                ?max_results: ::Integer
                                              ) -> _ListSecurityProfileApplicationsResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSecurityProfileApplicationsResponseSuccess

      interface _ListSecurityProfilePermissionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSecurityProfilePermissionsResponse]
        def permissions: () -> ::Array[::String]
        def next_token: () -> ::String
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_security_profile_permissions-instance_method
      def list_security_profile_permissions: (
                                               security_profile_id: ::String,
                                               instance_id: ::String,
                                               ?next_token: ::String,
                                               ?max_results: ::Integer
                                             ) -> _ListSecurityProfilePermissionsResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSecurityProfilePermissionsResponseSuccess

      interface _ListSecurityProfilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSecurityProfilesResponse]
        def security_profile_summary_list: () -> ::Array[Types::SecurityProfileSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_security_profiles-instance_method
      def list_security_profiles: (
                                    instance_id: ::String,
                                    ?next_token: ::String,
                                    ?max_results: ::Integer
                                  ) -> _ListSecurityProfilesResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSecurityProfilesResponseSuccess

      interface _ListTagsForResourceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTagsForResourceResponse]
        def tags: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_tags_for_resource-instance_method
      def list_tags_for_resource: (
                                    resource_arn: ::String
                                  ) -> _ListTagsForResourceResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTagsForResourceResponseSuccess

      interface _ListTaskTemplatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTaskTemplatesResponse]
        def task_templates: () -> ::Array[Types::TaskTemplateMetadata]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_task_templates-instance_method
      def list_task_templates: (
                                 instance_id: ::String,
                                 ?next_token: ::String,
                                 ?max_results: ::Integer,
                                 ?status: ("ACTIVE" | "INACTIVE"),
                                 ?name: ::String
                               ) -> _ListTaskTemplatesResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTaskTemplatesResponseSuccess

      interface _ListTrafficDistributionGroupUsersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTrafficDistributionGroupUsersResponse]
        def next_token: () -> ::String
        def traffic_distribution_group_user_summary_list: () -> ::Array[Types::TrafficDistributionGroupUserSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_traffic_distribution_group_users-instance_method
      def list_traffic_distribution_group_users: (
                                                   traffic_distribution_group_id: ::String,
                                                   ?max_results: ::Integer,
                                                   ?next_token: ::String
                                                 ) -> _ListTrafficDistributionGroupUsersResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTrafficDistributionGroupUsersResponseSuccess

      interface _ListTrafficDistributionGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTrafficDistributionGroupsResponse]
        def next_token: () -> ::String
        def traffic_distribution_group_summary_list: () -> ::Array[Types::TrafficDistributionGroupSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_traffic_distribution_groups-instance_method
      def list_traffic_distribution_groups: (
                                              ?max_results: ::Integer,
                                              ?next_token: ::String,
                                              ?instance_id: ::String
                                            ) -> _ListTrafficDistributionGroupsResponseSuccess
                                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTrafficDistributionGroupsResponseSuccess

      interface _ListUseCasesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListUseCasesResponse]
        def use_case_summary_list: () -> ::Array[Types::UseCase]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_use_cases-instance_method
      def list_use_cases: (
                            instance_id: ::String,
                            integration_association_id: ::String,
                            ?next_token: ::String,
                            ?max_results: ::Integer
                          ) -> _ListUseCasesResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListUseCasesResponseSuccess

      interface _ListUserHierarchyGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListUserHierarchyGroupsResponse]
        def user_hierarchy_group_summary_list: () -> ::Array[Types::HierarchyGroupSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_user_hierarchy_groups-instance_method
      def list_user_hierarchy_groups: (
                                        instance_id: ::String,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer
                                      ) -> _ListUserHierarchyGroupsResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListUserHierarchyGroupsResponseSuccess

      interface _ListUserProficienciesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListUserProficienciesResponse]
        def next_token: () -> ::String
        def user_proficiency_list: () -> ::Array[Types::UserProficiency]
        def last_modified_time: () -> ::Time
        def last_modified_region: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_user_proficiencies-instance_method
      def list_user_proficiencies: (
                                     instance_id: ::String,
                                     user_id: ::String,
                                     ?next_token: ::String,
                                     ?max_results: ::Integer
                                   ) -> _ListUserProficienciesResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListUserProficienciesResponseSuccess

      interface _ListUsersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListUsersResponse]
        def user_summary_list: () -> ::Array[Types::UserSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_users-instance_method
      def list_users: (
                        instance_id: ::String,
                        ?next_token: ::String,
                        ?max_results: ::Integer
                      ) -> _ListUsersResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListUsersResponseSuccess

      interface _ListViewVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListViewVersionsResponse]
        def view_version_summary_list: () -> ::Array[Types::ViewVersionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_view_versions-instance_method
      def list_view_versions: (
                                instance_id: ::String,
                                view_id: ::String,
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _ListViewVersionsResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListViewVersionsResponseSuccess

      interface _ListViewsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListViewsResponse]
        def views_summary_list: () -> ::Array[Types::ViewSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#list_views-instance_method
      def list_views: (
                        instance_id: ::String,
                        ?type: ("CUSTOMER_MANAGED" | "AWS_MANAGED"),
                        ?next_token: ::String,
                        ?max_results: ::Integer
                      ) -> _ListViewsResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListViewsResponseSuccess

      interface _MonitorContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::MonitorContactResponse]
        def contact_id: () -> ::String
        def contact_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#monitor_contact-instance_method
      def monitor_contact: (
                             instance_id: ::String,
                             contact_id: ::String,
                             user_id: ::String,
                             ?allowed_monitor_capabilities: Array[("SILENT_MONITOR" | "BARGE")],
                             ?client_token: ::String
                           ) -> _MonitorContactResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _MonitorContactResponseSuccess

      interface _PauseContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PauseContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#pause_contact-instance_method
      def pause_contact: (
                           contact_id: ::String,
                           instance_id: ::String,
                           ?contact_flow_id: ::String
                         ) -> _PauseContactResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PauseContactResponseSuccess

      interface _PutUserStatusResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PutUserStatusResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#put_user_status-instance_method
      def put_user_status: (
                             user_id: ::String,
                             instance_id: ::String,
                             agent_status_id: ::String
                           ) -> _PutUserStatusResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutUserStatusResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#release_phone_number-instance_method
      def release_phone_number: (
                                  phone_number_id: ::String,
                                  ?client_token: ::String
                                ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _ReplicateInstanceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ReplicateInstanceResponse]
        def id: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#replicate_instance-instance_method
      def replicate_instance: (
                                instance_id: ::String,
                                replica_region: ::String,
                                ?client_token: ::String,
                                replica_alias: ::String
                              ) -> _ReplicateInstanceResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ReplicateInstanceResponseSuccess

      interface _ResumeContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ResumeContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#resume_contact-instance_method
      def resume_contact: (
                            contact_id: ::String,
                            instance_id: ::String,
                            ?contact_flow_id: ::String
                          ) -> _ResumeContactResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ResumeContactResponseSuccess

      interface _ResumeContactRecordingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ResumeContactRecordingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#resume_contact_recording-instance_method
      def resume_contact_recording: (
                                      instance_id: ::String,
                                      contact_id: ::String,
                                      initial_contact_id: ::String,
                                      ?contact_recording_type: ("AGENT" | "IVR" | "SCREEN")
                                    ) -> _ResumeContactRecordingResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ResumeContactRecordingResponseSuccess

      interface _SearchAgentStatusesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchAgentStatusesResponse]
        def agent_statuses: () -> ::Array[Types::AgentStatus]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_agent_statuses-instance_method
      def search_agent_statuses: (
                                   instance_id: ::String,
                                   ?next_token: ::String,
                                   ?max_results: ::Integer,
                                   ?search_filter: {
                                     attribute_filter: {
                                       or_conditions: Array[
                                         {
                                           tag_conditions: Array[
                                             {
                                               tag_key: ::String?,
                                               tag_value: ::String?
                                             },
                                           ]?
                                         },
                                       ]?,
                                       and_condition: {
                                         tag_conditions: Array[
                                           {
                                             tag_key: ::String?,
                                             tag_value: ::String?
                                           },
                                         ]?
                                       }?,
                                       tag_condition: {
                                         tag_key: ::String?,
                                         tag_value: ::String?
                                       }?
                                     }?
                                   },
                                   ?search_criteria: {
                                     or_conditions: Array[
                                       untyped,
                                     ]?,
                                     and_conditions: Array[
                                       untyped,
                                     ]?,
                                     string_condition: {
                                       field_name: ::String?,
                                       value: ::String?,
                                       comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                     }?
                                   }
                                 ) -> _SearchAgentStatusesResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchAgentStatusesResponseSuccess

      interface _SearchAvailablePhoneNumbersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchAvailablePhoneNumbersResponse]
        def next_token: () -> ::String
        def available_numbers_list: () -> ::Array[Types::AvailableNumberSummary]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_available_phone_numbers-instance_method
      def search_available_phone_numbers: (
                                            ?target_arn: ::String,
                                            ?instance_id: ::String,
                                            phone_number_country_code: ("AF" | "AL" | "DZ" | "AS" | "AD" | "AO" | "AI" | "AQ" | "AG" | "AR" | "AM" | "AW" | "AU" | "AT" | "AZ" | "BS" | "BH" | "BD" | "BB" | "BY" | "BE" | "BZ" | "BJ" | "BM" | "BT" | "BO" | "BA" | "BW" | "BR" | "IO" | "VG" | "BN" | "BG" | "BF" | "BI" | "KH" | "CM" | "CA" | "CV" | "KY" | "CF" | "TD" | "CL" | "CN" | "CX" | "CC" | "CO" | "KM" | "CK" | "CR" | "HR" | "CU" | "CW" | "CY" | "CZ" | "CD" | "DK" | "DJ" | "DM" | "DO" | "TL" | "EC" | "EG" | "SV" | "GQ" | "ER" | "EE" | "ET" | "FK" | "FO" | "FJ" | "FI" | "FR" | "PF" | "GA" | "GM" | "GE" | "DE" | "GH" | "GI" | "GR" | "GL" | "GD" | "GU" | "GT" | "GG" | "GN" | "GW" | "GY" | "HT" | "HN" | "HK" | "HU" | "IS" | "IN" | "ID" | "IR" | "IQ" | "IE" | "IM" | "IL" | "IT" | "CI" | "JM" | "JP" | "JE" | "JO" | "KZ" | "KE" | "KI" | "KW" | "KG" | "LA" | "LV" | "LB" | "LS" | "LR" | "LY" | "LI" | "LT" | "LU" | "MO" | "MK" | "MG" | "MW" | "MY" | "MV" | "ML" | "MT" | "MH" | "MR" | "MU" | "YT" | "MX" | "FM" | "MD" | "MC" | "MN" | "ME" | "MS" | "MA" | "MZ" | "MM" | "NA" | "NR" | "NP" | "NL" | "AN" | "NC" | "NZ" | "NI" | "NE" | "NG" | "NU" | "KP" | "MP" | "NO" | "OM" | "PK" | "PW" | "PA" | "PG" | "PY" | "PE" | "PH" | "PN" | "PL" | "PT" | "PR" | "QA" | "CG" | "RE" | "RO" | "RU" | "RW" | "BL" | "SH" | "KN" | "LC" | "MF" | "PM" | "VC" | "WS" | "SM" | "ST" | "SA" | "SN" | "RS" | "SC" | "SL" | "SG" | "SX" | "SK" | "SI" | "SB" | "SO" | "ZA" | "KR" | "ES" | "LK" | "SD" | "SR" | "SJ" | "SZ" | "SE" | "CH" | "SY" | "TW" | "TJ" | "TZ" | "TH" | "TG" | "TK" | "TO" | "TT" | "TN" | "TR" | "TM" | "TC" | "TV" | "VI" | "UG" | "UA" | "AE" | "GB" | "US" | "UY" | "UZ" | "VU" | "VA" | "VE" | "VN" | "WF" | "EH" | "YE" | "ZM" | "ZW"),
                                            phone_number_type: ("TOLL_FREE" | "DID" | "UIFN" | "SHARED" | "THIRD_PARTY_TF" | "THIRD_PARTY_DID" | "SHORT_CODE"),
                                            ?phone_number_prefix: ::String,
                                            ?max_results: ::Integer,
                                            ?next_token: ::String
                                          ) -> _SearchAvailablePhoneNumbersResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchAvailablePhoneNumbersResponseSuccess

      interface _SearchContactFlowModulesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchContactFlowModulesResponse]
        def contact_flow_modules: () -> ::Array[Types::ContactFlowModule]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_contact_flow_modules-instance_method
      def search_contact_flow_modules: (
                                         instance_id: ::String,
                                         ?next_token: ::String,
                                         ?max_results: ::Integer,
                                         ?search_filter: {
                                           tag_filter: {
                                             or_conditions: Array[
                                               Array[
                                                 {
                                                   tag_key: ::String?,
                                                   tag_value: ::String?
                                                 },
                                               ],
                                             ]?,
                                             and_conditions: Array[
                                               {
                                                 tag_key: ::String?,
                                                 tag_value: ::String?
                                               },
                                             ]?,
                                             tag_condition: {
                                               tag_key: ::String?,
                                               tag_value: ::String?
                                             }?
                                           }?
                                         },
                                         ?search_criteria: {
                                           or_conditions: Array[
                                             untyped,
                                           ]?,
                                           and_conditions: Array[
                                             untyped,
                                           ]?,
                                           string_condition: {
                                             field_name: ::String?,
                                             value: ::String?,
                                             comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                           }?,
                                           state_condition: ("ACTIVE" | "ARCHIVED")?,
                                           status_condition: ("PUBLISHED" | "SAVED")?
                                         }
                                       ) -> _SearchContactFlowModulesResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchContactFlowModulesResponseSuccess

      interface _SearchContactFlowsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchContactFlowsResponse]
        def contact_flows: () -> ::Array[Types::ContactFlow]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_contact_flows-instance_method
      def search_contact_flows: (
                                  instance_id: ::String,
                                  ?next_token: ::String,
                                  ?max_results: ::Integer,
                                  ?search_filter: {
                                    tag_filter: {
                                      or_conditions: Array[
                                        Array[
                                          {
                                            tag_key: ::String?,
                                            tag_value: ::String?
                                          },
                                        ],
                                      ]?,
                                      and_conditions: Array[
                                        {
                                          tag_key: ::String?,
                                          tag_value: ::String?
                                        },
                                      ]?,
                                      tag_condition: {
                                        tag_key: ::String?,
                                        tag_value: ::String?
                                      }?
                                    }?
                                  },
                                  ?search_criteria: {
                                    or_conditions: Array[
                                      untyped,
                                    ]?,
                                    and_conditions: Array[
                                      untyped,
                                    ]?,
                                    string_condition: {
                                      field_name: ::String?,
                                      value: ::String?,
                                      comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                    }?,
                                    type_condition: ("CONTACT_FLOW" | "CUSTOMER_QUEUE" | "CUSTOMER_HOLD" | "CUSTOMER_WHISPER" | "AGENT_HOLD" | "AGENT_WHISPER" | "OUTBOUND_WHISPER" | "AGENT_TRANSFER" | "QUEUE_TRANSFER")?,
                                    state_condition: ("ACTIVE" | "ARCHIVED")?,
                                    status_condition: ("PUBLISHED" | "SAVED")?
                                  }
                                ) -> _SearchContactFlowsResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchContactFlowsResponseSuccess

      interface _SearchContactsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchContactsResponse]
        def contacts: () -> ::Array[Types::ContactSearchSummary]
        def next_token: () -> ::String
        def total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_contacts-instance_method
      def search_contacts: (
                             instance_id: ::String,
                             time_range: {
                               type: ("INITIATION_TIMESTAMP" | "SCHEDULED_TIMESTAMP" | "CONNECTED_TO_AGENT_TIMESTAMP" | "DISCONNECT_TIMESTAMP"),
                               start_time: ::Time,
                               end_time: ::Time
                             },
                             ?search_criteria: {
                               agent_ids: Array[::String]?,
                               agent_hierarchy_groups: {
                                 l1_ids: Array[::String]?,
                                 l2_ids: Array[::String]?,
                                 l3_ids: Array[::String]?,
                                 l4_ids: Array[::String]?,
                                 l5_ids: Array[::String]?
                               }?,
                               channels: Array[("VOICE" | "CHAT" | "TASK" | "EMAIL")]?,
                               contact_analysis: {
                                 transcript: {
                                   criteria: Array[
                                     {
                                       participant_role: ("AGENT" | "CUSTOMER" | "SYSTEM" | "CUSTOM_BOT" | "SUPERVISOR"),
                                       search_text: Array[::String],
                                       match_type: ("MATCH_ALL" | "MATCH_ANY")
                                     },
                                   ],
                                   match_type: ("MATCH_ALL" | "MATCH_ANY")?
                                 }?
                               }?,
                               initiation_methods: Array[("INBOUND" | "OUTBOUND" | "TRANSFER" | "QUEUE_TRANSFER" | "CALLBACK" | "API" | "DISCONNECT" | "MONITOR" | "EXTERNAL_OUTBOUND" | "WEBRTC_API" | "AGENT_REPLY" | "FLOW")]?,
                               queue_ids: Array[::String]?,
                               searchable_contact_attributes: {
                                 criteria: Array[
                                   {
                                     key: ::String,
                                     values: Array[::String]
                                   },
                                 ],
                                 match_type: ("MATCH_ALL" | "MATCH_ANY")?
                               }?,
                               searchable_segment_attributes: {
                                 criteria: Array[
                                   {
                                     key: ::String,
                                     values: Array[::String]
                                   },
                                 ],
                                 match_type: ("MATCH_ALL" | "MATCH_ANY")?
                               }?
                             },
                             ?max_results: ::Integer,
                             ?next_token: ::String,
                             ?sort: {
                               field_name: ("INITIATION_TIMESTAMP" | "SCHEDULED_TIMESTAMP" | "CONNECTED_TO_AGENT_TIMESTAMP" | "DISCONNECT_TIMESTAMP" | "INITIATION_METHOD" | "CHANNEL"),
                               order: ("ASCENDING" | "DESCENDING")
                             }
                           ) -> _SearchContactsResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchContactsResponseSuccess

      interface _SearchEmailAddressesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchEmailAddressesResponse]
        def next_token: () -> ::String
        def email_addresses: () -> ::Array[Types::EmailAddressMetadata]
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_email_addresses-instance_method
      def search_email_addresses: (
                                    instance_id: ::String,
                                    ?max_results: ::Integer,
                                    ?next_token: ::String,
                                    ?search_criteria: {
                                      or_conditions: Array[
                                        untyped,
                                      ]?,
                                      and_conditions: Array[
                                        untyped,
                                      ]?,
                                      string_condition: {
                                        field_name: ::String?,
                                        value: ::String?,
                                        comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                      }?
                                    },
                                    ?search_filter: {
                                      tag_filter: {
                                        or_conditions: Array[
                                          Array[
                                            {
                                              tag_key: ::String?,
                                              tag_value: ::String?
                                            },
                                          ],
                                        ]?,
                                        and_conditions: Array[
                                          {
                                            tag_key: ::String?,
                                            tag_value: ::String?
                                          },
                                        ]?,
                                        tag_condition: {
                                          tag_key: ::String?,
                                          tag_value: ::String?
                                        }?
                                      }?
                                    }
                                  ) -> _SearchEmailAddressesResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchEmailAddressesResponseSuccess

      interface _SearchHoursOfOperationOverridesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchHoursOfOperationOverridesResponse]
        def hours_of_operation_overrides: () -> ::Array[Types::HoursOfOperationOverride]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_hours_of_operation_overrides-instance_method
      def search_hours_of_operation_overrides: (
                                                 instance_id: ::String,
                                                 ?next_token: ::String,
                                                 ?max_results: ::Integer,
                                                 ?search_filter: {
                                                   tag_filter: {
                                                     or_conditions: Array[
                                                       Array[
                                                         {
                                                           tag_key: ::String?,
                                                           tag_value: ::String?
                                                         },
                                                       ],
                                                     ]?,
                                                     and_conditions: Array[
                                                       {
                                                         tag_key: ::String?,
                                                         tag_value: ::String?
                                                       },
                                                     ]?,
                                                     tag_condition: {
                                                       tag_key: ::String?,
                                                       tag_value: ::String?
                                                     }?
                                                   }?
                                                 },
                                                 ?search_criteria: {
                                                   or_conditions: Array[
                                                     untyped,
                                                   ]?,
                                                   and_conditions: Array[
                                                     untyped,
                                                   ]?,
                                                   string_condition: {
                                                     field_name: ::String?,
                                                     value: ::String?,
                                                     comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                                   }?,
                                                   date_condition: {
                                                     field_name: ::String?,
                                                     value: ::String?,
                                                     comparison_type: ("GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL_TO" | "LESS_THAN_OR_EQUAL_TO" | "EQUAL_TO")?
                                                   }?
                                                 }
                                               ) -> _SearchHoursOfOperationOverridesResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchHoursOfOperationOverridesResponseSuccess

      interface _SearchHoursOfOperationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchHoursOfOperationsResponse]
        def hours_of_operations: () -> ::Array[Types::HoursOfOperation]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_hours_of_operations-instance_method
      def search_hours_of_operations: (
                                        instance_id: ::String,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer,
                                        ?search_filter: {
                                          tag_filter: {
                                            or_conditions: Array[
                                              Array[
                                                {
                                                  tag_key: ::String?,
                                                  tag_value: ::String?
                                                },
                                              ],
                                            ]?,
                                            and_conditions: Array[
                                              {
                                                tag_key: ::String?,
                                                tag_value: ::String?
                                              },
                                            ]?,
                                            tag_condition: {
                                              tag_key: ::String?,
                                              tag_value: ::String?
                                            }?
                                          }?
                                        },
                                        ?search_criteria: {
                                          or_conditions: Array[
                                            untyped,
                                          ]?,
                                          and_conditions: Array[
                                            untyped,
                                          ]?,
                                          string_condition: {
                                            field_name: ::String?,
                                            value: ::String?,
                                            comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                          }?
                                        }
                                      ) -> _SearchHoursOfOperationsResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchHoursOfOperationsResponseSuccess

      interface _SearchPredefinedAttributesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchPredefinedAttributesResponse]
        def predefined_attributes: () -> ::Array[Types::PredefinedAttribute]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_predefined_attributes-instance_method
      def search_predefined_attributes: (
                                          instance_id: ::String,
                                          ?next_token: ::String,
                                          ?max_results: ::Integer,
                                          ?search_criteria: {
                                            or_conditions: Array[
                                              untyped,
                                            ]?,
                                            and_conditions: Array[
                                              untyped,
                                            ]?,
                                            string_condition: {
                                              field_name: ::String?,
                                              value: ::String?,
                                              comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                            }?
                                          }
                                        ) -> _SearchPredefinedAttributesResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchPredefinedAttributesResponseSuccess

      interface _SearchPromptsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchPromptsResponse]
        def prompts: () -> ::Array[Types::Prompt]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_prompts-instance_method
      def search_prompts: (
                            instance_id: ::String,
                            ?next_token: ::String,
                            ?max_results: ::Integer,
                            ?search_filter: {
                              tag_filter: {
                                or_conditions: Array[
                                  Array[
                                    {
                                      tag_key: ::String?,
                                      tag_value: ::String?
                                    },
                                  ],
                                ]?,
                                and_conditions: Array[
                                  {
                                    tag_key: ::String?,
                                    tag_value: ::String?
                                  },
                                ]?,
                                tag_condition: {
                                  tag_key: ::String?,
                                  tag_value: ::String?
                                }?
                              }?
                            },
                            ?search_criteria: {
                              or_conditions: Array[
                                untyped,
                              ]?,
                              and_conditions: Array[
                                untyped,
                              ]?,
                              string_condition: {
                                field_name: ::String?,
                                value: ::String?,
                                comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                              }?
                            }
                          ) -> _SearchPromptsResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchPromptsResponseSuccess

      interface _SearchQueuesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchQueuesResponse]
        def queues: () -> ::Array[Types::Queue]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_queues-instance_method
      def search_queues: (
                           instance_id: ::String,
                           ?next_token: ::String,
                           ?max_results: ::Integer,
                           ?search_filter: {
                             tag_filter: {
                               or_conditions: Array[
                                 Array[
                                   {
                                     tag_key: ::String?,
                                     tag_value: ::String?
                                   },
                                 ],
                               ]?,
                               and_conditions: Array[
                                 {
                                   tag_key: ::String?,
                                   tag_value: ::String?
                                 },
                               ]?,
                               tag_condition: {
                                 tag_key: ::String?,
                                 tag_value: ::String?
                               }?
                             }?
                           },
                           ?search_criteria: {
                             or_conditions: Array[
                               untyped,
                             ]?,
                             and_conditions: Array[
                               untyped,
                             ]?,
                             string_condition: {
                               field_name: ::String?,
                               value: ::String?,
                               comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                             }?,
                             queue_type_condition: ("STANDARD")?
                           }
                         ) -> _SearchQueuesResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchQueuesResponseSuccess

      interface _SearchQuickConnectsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchQuickConnectsResponse]
        def quick_connects: () -> ::Array[Types::QuickConnect]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_quick_connects-instance_method
      def search_quick_connects: (
                                   instance_id: ::String,
                                   ?next_token: ::String,
                                   ?max_results: ::Integer,
                                   ?search_filter: {
                                     tag_filter: {
                                       or_conditions: Array[
                                         Array[
                                           {
                                             tag_key: ::String?,
                                             tag_value: ::String?
                                           },
                                         ],
                                       ]?,
                                       and_conditions: Array[
                                         {
                                           tag_key: ::String?,
                                           tag_value: ::String?
                                         },
                                       ]?,
                                       tag_condition: {
                                         tag_key: ::String?,
                                         tag_value: ::String?
                                       }?
                                     }?
                                   },
                                   ?search_criteria: {
                                     or_conditions: Array[
                                       untyped,
                                     ]?,
                                     and_conditions: Array[
                                       untyped,
                                     ]?,
                                     string_condition: {
                                       field_name: ::String?,
                                       value: ::String?,
                                       comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                     }?
                                   }
                                 ) -> _SearchQuickConnectsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchQuickConnectsResponseSuccess

      interface _SearchResourceTagsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchResourceTagsResponse]
        def tags: () -> ::Array[Types::TagSet]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_resource_tags-instance_method
      def search_resource_tags: (
                                  instance_id: ::String,
                                  ?resource_types: Array[::String],
                                  ?next_token: ::String,
                                  ?max_results: ::Integer,
                                  ?search_criteria: {
                                    tag_search_condition: {
                                      tag_key: ::String?,
                                      tag_value: ::String?,
                                      tag_key_comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?,
                                      tag_value_comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                    }?
                                  }
                                ) -> _SearchResourceTagsResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchResourceTagsResponseSuccess

      interface _SearchRoutingProfilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchRoutingProfilesResponse]
        def routing_profiles: () -> ::Array[Types::RoutingProfile]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_routing_profiles-instance_method
      def search_routing_profiles: (
                                     instance_id: ::String,
                                     ?next_token: ::String,
                                     ?max_results: ::Integer,
                                     ?search_filter: {
                                       tag_filter: {
                                         or_conditions: Array[
                                           Array[
                                             {
                                               tag_key: ::String?,
                                               tag_value: ::String?
                                             },
                                           ],
                                         ]?,
                                         and_conditions: Array[
                                           {
                                             tag_key: ::String?,
                                             tag_value: ::String?
                                           },
                                         ]?,
                                         tag_condition: {
                                           tag_key: ::String?,
                                           tag_value: ::String?
                                         }?
                                       }?
                                     },
                                     ?search_criteria: {
                                       or_conditions: Array[
                                         untyped,
                                       ]?,
                                       and_conditions: Array[
                                         untyped,
                                       ]?,
                                       string_condition: {
                                         field_name: ::String?,
                                         value: ::String?,
                                         comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                       }?
                                     }
                                   ) -> _SearchRoutingProfilesResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchRoutingProfilesResponseSuccess

      interface _SearchSecurityProfilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchSecurityProfilesResponse]
        def security_profiles: () -> ::Array[Types::SecurityProfileSearchSummary]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_security_profiles-instance_method
      def search_security_profiles: (
                                      instance_id: ::String,
                                      ?next_token: ::String,
                                      ?max_results: ::Integer,
                                      ?search_criteria: {
                                        or_conditions: Array[
                                          untyped,
                                        ]?,
                                        and_conditions: Array[
                                          untyped,
                                        ]?,
                                        string_condition: {
                                          field_name: ::String?,
                                          value: ::String?,
                                          comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                        }?
                                      },
                                      ?search_filter: {
                                        tag_filter: {
                                          or_conditions: Array[
                                            Array[
                                              {
                                                tag_key: ::String?,
                                                tag_value: ::String?
                                              },
                                            ],
                                          ]?,
                                          and_conditions: Array[
                                            {
                                              tag_key: ::String?,
                                              tag_value: ::String?
                                            },
                                          ]?,
                                          tag_condition: {
                                            tag_key: ::String?,
                                            tag_value: ::String?
                                          }?
                                        }?
                                      }
                                    ) -> _SearchSecurityProfilesResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchSecurityProfilesResponseSuccess

      interface _SearchUserHierarchyGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchUserHierarchyGroupsResponse]
        def user_hierarchy_groups: () -> ::Array[Types::HierarchyGroup]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_user_hierarchy_groups-instance_method
      def search_user_hierarchy_groups: (
                                          instance_id: ::String,
                                          ?next_token: ::String,
                                          ?max_results: ::Integer,
                                          ?search_filter: {
                                            attribute_filter: {
                                              or_conditions: Array[
                                                {
                                                  tag_conditions: Array[
                                                    {
                                                      tag_key: ::String?,
                                                      tag_value: ::String?
                                                    },
                                                  ]?
                                                },
                                              ]?,
                                              and_condition: {
                                                tag_conditions: Array[
                                                  {
                                                    tag_key: ::String?,
                                                    tag_value: ::String?
                                                  },
                                                ]?
                                              }?,
                                              tag_condition: {
                                                tag_key: ::String?,
                                                tag_value: ::String?
                                              }?
                                            }?
                                          },
                                          ?search_criteria: {
                                            or_conditions: Array[
                                              untyped,
                                            ]?,
                                            and_conditions: Array[
                                              untyped,
                                            ]?,
                                            string_condition: {
                                              field_name: ::String?,
                                              value: ::String?,
                                              comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                            }?
                                          }
                                        ) -> _SearchUserHierarchyGroupsResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchUserHierarchyGroupsResponseSuccess

      interface _SearchUsersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchUsersResponse]
        def users: () -> ::Array[Types::UserSearchSummary]
        def next_token: () -> ::String
        def approximate_total_count: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_users-instance_method
      def search_users: (
                          instance_id: ::String,
                          ?next_token: ::String,
                          ?max_results: ::Integer,
                          ?search_filter: {
                            tag_filter: {
                              or_conditions: Array[
                                Array[
                                  {
                                    tag_key: ::String?,
                                    tag_value: ::String?
                                  },
                                ],
                              ]?,
                              and_conditions: Array[
                                {
                                  tag_key: ::String?,
                                  tag_value: ::String?
                                },
                              ]?,
                              tag_condition: {
                                tag_key: ::String?,
                                tag_value: ::String?
                              }?
                            }?,
                            user_attribute_filter: {
                              or_conditions: Array[
                                {
                                  tag_conditions: Array[
                                    {
                                      tag_key: ::String?,
                                      tag_value: ::String?
                                    },
                                  ]?,
                                  hierarchy_group_condition: {
                                    value: ::String?,
                                    hierarchy_group_match_type: ("EXACT" | "WITH_CHILD_GROUPS")?
                                  }?
                                },
                              ]?,
                              and_condition: {
                                tag_conditions: Array[
                                  {
                                    tag_key: ::String?,
                                    tag_value: ::String?
                                  },
                                ]?,
                                hierarchy_group_condition: {
                                  value: ::String?,
                                  hierarchy_group_match_type: ("EXACT" | "WITH_CHILD_GROUPS")?
                                }?
                              }?,
                              tag_condition: {
                                tag_key: ::String?,
                                tag_value: ::String?
                              }?,
                              hierarchy_group_condition: {
                                value: ::String?,
                                hierarchy_group_match_type: ("EXACT" | "WITH_CHILD_GROUPS")?
                              }?
                            }?
                          },
                          ?search_criteria: {
                            or_conditions: Array[
                              untyped,
                            ]?,
                            and_conditions: Array[
                              untyped,
                            ]?,
                            string_condition: {
                              field_name: ::String?,
                              value: ::String?,
                              comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                            }?,
                            list_condition: {
                              target_list_type: ("PROFICIENCIES")?,
                              conditions: Array[
                                {
                                  string_condition: {
                                    field_name: ::String?,
                                    value: ::String?,
                                    comparison_type: ("STARTS_WITH" | "CONTAINS" | "EXACT")?
                                  }?,
                                  number_condition: {
                                    field_name: ::String?,
                                    min_value: ::Integer?,
                                    max_value: ::Integer?,
                                    comparison_type: ("GREATER_OR_EQUAL" | "GREATER" | "LESSER_OR_EQUAL" | "LESSER" | "EQUAL" | "NOT_EQUAL" | "RANGE")?
                                  }?
                                },
                              ]?
                            }?,
                            hierarchy_group_condition: {
                              value: ::String?,
                              hierarchy_group_match_type: ("EXACT" | "WITH_CHILD_GROUPS")?
                            }?
                          }
                        ) -> _SearchUsersResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchUsersResponseSuccess

      interface _SearchVocabulariesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchVocabulariesResponse]
        def vocabulary_summary_list: () -> ::Array[Types::VocabularySummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#search_vocabularies-instance_method
      def search_vocabularies: (
                                 instance_id: ::String,
                                 ?max_results: ::Integer,
                                 ?next_token: ::String,
                                 ?state: ("CREATION_IN_PROGRESS" | "ACTIVE" | "CREATION_FAILED" | "DELETE_IN_PROGRESS"),
                                 ?name_starts_with: ::String,
                                 ?language_code: ("ar-AE" | "de-CH" | "de-DE" | "en-AB" | "en-AU" | "en-GB" | "en-IE" | "en-IN" | "en-US" | "en-WL" | "es-ES" | "es-US" | "fr-CA" | "fr-FR" | "hi-IN" | "it-IT" | "ja-JP" | "ko-KR" | "pt-BR" | "pt-PT" | "zh-CN" | "en-NZ" | "en-ZA" | "ca-ES" | "da-DK" | "fi-FI" | "id-ID" | "ms-MY" | "nl-NL" | "no-NO" | "pl-PL" | "sv-SE" | "tl-PH")
                               ) -> _SearchVocabulariesResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchVocabulariesResponseSuccess

      interface _SendChatIntegrationEventResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SendChatIntegrationEventResponse]
        def initial_contact_id: () -> ::String
        def new_chat_created: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#send_chat_integration_event-instance_method
      def send_chat_integration_event: (
                                         source_id: ::String,
                                         destination_id: ::String,
                                         ?subtype: ::String,
                                         event: {
                                           type: ("DISCONNECT" | "MESSAGE" | "EVENT"),
                                           content_type: ::String?,
                                           content: ::String?
                                         },
                                         ?new_session_details: {
                                           supported_messaging_content_types: Array[::String]?,
                                           participant_details: {
                                             display_name: ::String
                                           }?,
                                           attributes: Hash[::String, ::String]?,
                                           streaming_configuration: {
                                             streaming_endpoint_arn: ::String
                                           }?
                                         }
                                       ) -> _SendChatIntegrationEventResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SendChatIntegrationEventResponseSuccess

      interface _SendOutboundEmailResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SendOutboundEmailResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#send_outbound_email-instance_method
      def send_outbound_email: (
                                 instance_id: ::String,
                                 from_email_address: {
                                   email_address: ::String,
                                   display_name: ::String?
                                 },
                                 destination_email_address: {
                                   email_address: ::String,
                                   display_name: ::String?
                                 },
                                 ?additional_recipients: {
                                   cc_email_addresses: Array[
                                     {
                                       email_address: ::String,
                                       display_name: ::String?
                                     },
                                   ]?
                                 },
                                 email_message: {
                                   message_source_type: ("TEMPLATE" | "RAW"),
                                   templated_message_config: {
                                     knowledge_base_id: ::String,
                                     message_template_id: ::String,
                                     template_attributes: {
                                       custom_attributes: Hash[::String, ::String]?,
                                       customer_profile_attributes: ::String?
                                     }
                                   }?,
                                   raw_message: {
                                     subject: ::String,
                                     body: ::String,
                                     content_type: ::String
                                   }?
                                 },
                                 traffic_type: ("GENERAL" | "CAMPAIGN"),
                                 ?source_campaign: {
                                   campaign_id: ::String?,
                                   outbound_request_id: ::String?
                                 },
                                 ?client_token: ::String
                               ) -> _SendOutboundEmailResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SendOutboundEmailResponseSuccess

      interface _StartAttachedFileUploadResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartAttachedFileUploadResponse]
        def file_arn: () -> ::String
        def file_id: () -> ::String
        def creation_time: () -> ::String
        def file_status: () -> ("APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")
        def created_by: () -> Types::CreatedByInfo
        def upload_url_metadata: () -> Types::UploadUrlMetadata
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_attached_file_upload-instance_method
      def start_attached_file_upload: (
                                        ?client_token: ::String,
                                        instance_id: ::String,
                                        file_name: ::String,
                                        file_size_in_bytes: ::Integer,
                                        ?url_expiry_in_seconds: ::Integer,
                                        file_use_case_type: ("EMAIL_MESSAGE" | "ATTACHMENT"),
                                        associated_resource_arn: ::String,
                                        ?created_by: {
                                          connect_user_arn: ::String?,
                                          aws_identity_arn: ::String?
                                        },
                                        ?tags: Hash[::String, ::String]
                                      ) -> _StartAttachedFileUploadResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartAttachedFileUploadResponseSuccess

      interface _StartChatContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartChatContactResponse]
        def contact_id: () -> ::String
        def participant_id: () -> ::String
        def participant_token: () -> ::String
        def continued_from_contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_chat_contact-instance_method
      def start_chat_contact: (
                                instance_id: ::String,
                                contact_flow_id: ::String,
                                ?attributes: Hash[::String, ::String],
                                participant_details: {
                                  display_name: ::String
                                },
                                ?initial_message: {
                                  content_type: ::String,
                                  content: ::String
                                },
                                ?client_token: ::String,
                                ?chat_duration_in_minutes: ::Integer,
                                ?supported_messaging_content_types: Array[::String],
                                ?persistent_chat: {
                                  rehydration_type: ("ENTIRE_PAST_SESSION" | "FROM_SEGMENT")?,
                                  source_contact_id: ::String?
                                },
                                ?related_contact_id: ::String,
                                ?segment_attributes: Hash[::String, {
                                    value_string: ::String?,
                                    value_map: Hash[::String, untyped]?,
                                    value_integer: ::Integer?
                                  }],
                                ?customer_id: ::String
                              ) -> _StartChatContactResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartChatContactResponseSuccess

      interface _StartContactEvaluationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartContactEvaluationResponse]
        def evaluation_id: () -> ::String
        def evaluation_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_contact_evaluation-instance_method
      def start_contact_evaluation: (
                                      instance_id: ::String,
                                      contact_id: ::String,
                                      evaluation_form_id: ::String,
                                      ?client_token: ::String
                                    ) -> _StartContactEvaluationResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartContactEvaluationResponseSuccess

      interface _StartContactRecordingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartContactRecordingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_contact_recording-instance_method
      def start_contact_recording: (
                                     instance_id: ::String,
                                     contact_id: ::String,
                                     initial_contact_id: ::String,
                                     voice_recording_configuration: {
                                       voice_recording_track: ("FROM_AGENT" | "TO_AGENT" | "ALL")?,
                                       ivr_recording_track: ("ALL")?
                                     }
                                   ) -> _StartContactRecordingResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartContactRecordingResponseSuccess

      interface _StartContactStreamingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartContactStreamingResponse]
        def streaming_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_contact_streaming-instance_method
      def start_contact_streaming: (
                                     instance_id: ::String,
                                     contact_id: ::String,
                                     chat_streaming_configuration: {
                                       streaming_endpoint_arn: ::String
                                     },
                                     client_token: ::String
                                   ) -> _StartContactStreamingResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartContactStreamingResponseSuccess

      interface _StartEmailContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartEmailContactResponse]
        def contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_email_contact-instance_method
      def start_email_contact: (
                                 instance_id: ::String,
                                 from_email_address: {
                                   email_address: ::String,
                                   display_name: ::String?
                                 },
                                 destination_email_address: ::String,
                                 ?description: ::String,
                                 ?references: Hash[::String, {
                                     value: ::String?,
                                     type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                     status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                     arn: ::String?,
                                     status_reason: ::String?
                                   }],
                                 ?name: ::String,
                                 email_message: {
                                   message_source_type: ("RAW"),
                                   raw_message: {
                                     subject: ::String,
                                     body: ::String,
                                     content_type: ::String,
                                     headers: Hash[("REFERENCES" | "MESSAGE_ID" | "IN_REPLY_TO" | "X_SES_SPAM_VERDICT" | "X_SES_VIRUS_VERDICT"), ::String]?
                                   }?
                                 },
                                 ?additional_recipients: {
                                   to_addresses: Array[
                                     {
                                       email_address: ::String,
                                       display_name: ::String?
                                     },
                                   ]?,
                                   cc_addresses: Array[
                                     {
                                       email_address: ::String,
                                       display_name: ::String?
                                     },
                                   ]?
                                 },
                                 ?attachments: Array[
                                   {
                                     file_name: ::String,
                                     s3_url: ::String
                                   },
                                 ],
                                 ?contact_flow_id: ::String,
                                 ?related_contact_id: ::String,
                                 ?attributes: Hash[::String, ::String],
                                 ?segment_attributes: Hash[::String, {
                                     value_string: ::String?,
                                     value_map: Hash[::String, untyped]?,
                                     value_integer: ::Integer?
                                   }],
                                 ?client_token: ::String
                               ) -> _StartEmailContactResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartEmailContactResponseSuccess

      interface _StartOutboundChatContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartOutboundChatContactResponse]
        def contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_outbound_chat_contact-instance_method
      def start_outbound_chat_contact: (
                                         source_endpoint: {
                                           type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                                           address: ::String?
                                         },
                                         destination_endpoint: {
                                           type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                                           address: ::String?
                                         },
                                         instance_id: ::String,
                                         segment_attributes: Hash[::String, {
                                             value_string: ::String?,
                                             value_map: Hash[::String, untyped]?,
                                             value_integer: ::Integer?
                                           }],
                                         ?attributes: Hash[::String, ::String],
                                         contact_flow_id: ::String,
                                         ?chat_duration_in_minutes: ::Integer,
                                         ?participant_details: {
                                           display_name: ::String
                                         },
                                         ?initial_system_message: {
                                           content_type: ::String,
                                           content: ::String
                                         },
                                         ?related_contact_id: ::String,
                                         ?supported_messaging_content_types: Array[::String],
                                         ?client_token: ::String
                                       ) -> _StartOutboundChatContactResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartOutboundChatContactResponseSuccess

      interface _StartOutboundEmailContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartOutboundEmailContactResponse]
        def contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_outbound_email_contact-instance_method
      def start_outbound_email_contact: (
                                          instance_id: ::String,
                                          contact_id: ::String,
                                          ?from_email_address: {
                                            email_address: ::String,
                                            display_name: ::String?
                                          },
                                          destination_email_address: {
                                            email_address: ::String,
                                            display_name: ::String?
                                          },
                                          ?additional_recipients: {
                                            cc_email_addresses: Array[
                                              {
                                                email_address: ::String,
                                                display_name: ::String?
                                              },
                                            ]?
                                          },
                                          email_message: {
                                            message_source_type: ("TEMPLATE" | "RAW"),
                                            templated_message_config: {
                                              knowledge_base_id: ::String,
                                              message_template_id: ::String,
                                              template_attributes: {
                                                custom_attributes: Hash[::String, ::String]?,
                                                customer_profile_attributes: ::String?
                                              }
                                            }?,
                                            raw_message: {
                                              subject: ::String,
                                              body: ::String,
                                              content_type: ::String
                                            }?
                                          },
                                          ?client_token: ::String
                                        ) -> _StartOutboundEmailContactResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartOutboundEmailContactResponseSuccess

      interface _StartOutboundVoiceContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartOutboundVoiceContactResponse]
        def contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_outbound_voice_contact-instance_method
      def start_outbound_voice_contact: (
                                          ?name: ::String,
                                          ?description: ::String,
                                          ?references: Hash[::String, {
                                              value: ::String?,
                                              type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                              status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                              arn: ::String?,
                                              status_reason: ::String?
                                            }],
                                          ?related_contact_id: ::String,
                                          destination_phone_number: ::String,
                                          contact_flow_id: ::String,
                                          instance_id: ::String,
                                          ?client_token: ::String,
                                          ?source_phone_number: ::String,
                                          ?queue_id: ::String,
                                          ?attributes: Hash[::String, ::String],
                                          ?answer_machine_detection_config: {
                                            enable_answer_machine_detection: bool?,
                                            await_answer_machine_prompt: bool?
                                          },
                                          ?campaign_id: ::String,
                                          ?traffic_type: ("GENERAL" | "CAMPAIGN")
                                        ) -> _StartOutboundVoiceContactResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartOutboundVoiceContactResponseSuccess

      interface _StartScreenSharingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartScreenSharingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_screen_sharing-instance_method
      def start_screen_sharing: (
                                  ?client_token: ::String,
                                  instance_id: ::String,
                                  contact_id: ::String
                                ) -> _StartScreenSharingResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartScreenSharingResponseSuccess

      interface _StartTaskContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartTaskContactResponse]
        def contact_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_task_contact-instance_method
      def start_task_contact: (
                                instance_id: ::String,
                                ?previous_contact_id: ::String,
                                ?contact_flow_id: ::String,
                                ?attributes: Hash[::String, ::String],
                                name: ::String,
                                ?references: Hash[::String, {
                                    value: ::String?,
                                    type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                    status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                    arn: ::String?,
                                    status_reason: ::String?
                                  }],
                                ?description: ::String,
                                ?client_token: ::String,
                                ?scheduled_time: ::Time,
                                ?task_template_id: ::String,
                                ?quick_connect_id: ::String,
                                ?related_contact_id: ::String,
                                ?segment_attributes: Hash[::String, {
                                    value_string: ::String?,
                                    value_map: Hash[::String, untyped]?,
                                    value_integer: ::Integer?
                                  }]
                              ) -> _StartTaskContactResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartTaskContactResponseSuccess

      interface _StartWebRTCContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartWebRTCContactResponse]
        def connection_data: () -> Types::ConnectionData
        def contact_id: () -> ::String
        def participant_id: () -> ::String
        def participant_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#start_web_rtc_contact-instance_method
      def start_web_rtc_contact: (
                                   ?attributes: Hash[::String, ::String],
                                   ?client_token: ::String,
                                   contact_flow_id: ::String,
                                   instance_id: ::String,
                                   ?allowed_capabilities: {
                                     customer: {
                                       video: ("SEND")?,
                                       screen_share: ("SEND")?
                                     }?,
                                     agent: {
                                       video: ("SEND")?,
                                       screen_share: ("SEND")?
                                     }?
                                   },
                                   participant_details: {
                                     display_name: ::String
                                   },
                                   ?related_contact_id: ::String,
                                   ?references: Hash[::String, {
                                       value: ::String?,
                                       type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                       status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                       arn: ::String?,
                                       status_reason: ::String?
                                     }],
                                   ?description: ::String
                                 ) -> _StartWebRTCContactResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartWebRTCContactResponseSuccess

      interface _StopContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StopContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#stop_contact-instance_method
      def stop_contact: (
                          contact_id: ::String,
                          instance_id: ::String,
                          ?disconnect_reason: {
                            code: ::String?
                          }
                        ) -> _StopContactResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StopContactResponseSuccess

      interface _StopContactRecordingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StopContactRecordingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#stop_contact_recording-instance_method
      def stop_contact_recording: (
                                    instance_id: ::String,
                                    contact_id: ::String,
                                    initial_contact_id: ::String,
                                    ?contact_recording_type: ("AGENT" | "IVR" | "SCREEN")
                                  ) -> _StopContactRecordingResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StopContactRecordingResponseSuccess

      interface _StopContactStreamingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StopContactStreamingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#stop_contact_streaming-instance_method
      def stop_contact_streaming: (
                                    instance_id: ::String,
                                    contact_id: ::String,
                                    streaming_id: ::String
                                  ) -> _StopContactStreamingResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StopContactStreamingResponseSuccess

      interface _SubmitContactEvaluationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SubmitContactEvaluationResponse]
        def evaluation_id: () -> ::String
        def evaluation_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#submit_contact_evaluation-instance_method
      def submit_contact_evaluation: (
                                       instance_id: ::String,
                                       evaluation_id: ::String,
                                       ?answers: Hash[::String, {
                                           value: {
                                             string_value: ::String?,
                                             numeric_value: ::Float?,
                                             not_applicable: bool?
                                           }?
                                         }],
                                       ?notes: Hash[::String, {
                                           value: ::String?
                                         }]
                                     ) -> _SubmitContactEvaluationResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SubmitContactEvaluationResponseSuccess

      interface _SuspendContactRecordingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SuspendContactRecordingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#suspend_contact_recording-instance_method
      def suspend_contact_recording: (
                                       instance_id: ::String,
                                       contact_id: ::String,
                                       initial_contact_id: ::String,
                                       ?contact_recording_type: ("AGENT" | "IVR" | "SCREEN")
                                     ) -> _SuspendContactRecordingResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SuspendContactRecordingResponseSuccess

      interface _TagContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TagContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#tag_contact-instance_method
      def tag_contact: (
                         contact_id: ::String,
                         instance_id: ::String,
                         tags: Hash[::String, ::String]
                       ) -> _TagContactResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TagContactResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#tag_resource-instance_method
      def tag_resource: (
                          resource_arn: ::String,
                          tags: Hash[::String, ::String]
                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _TransferContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TransferContactResponse]
        def contact_id: () -> ::String
        def contact_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#transfer_contact-instance_method
      def transfer_contact: (
                              instance_id: ::String,
                              contact_id: ::String,
                              ?queue_id: ::String,
                              ?user_id: ::String,
                              contact_flow_id: ::String,
                              ?client_token: ::String
                            ) -> _TransferContactResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TransferContactResponseSuccess

      interface _UntagContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UntagContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#untag_contact-instance_method
      def untag_contact: (
                           contact_id: ::String,
                           instance_id: ::String,
                           tag_keys: Array[::String]
                         ) -> _UntagContactResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UntagContactResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#untag_resource-instance_method
      def untag_resource: (
                            resource_arn: ::String,
                            tag_keys: Array[::String]
                          ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_agent_status-instance_method
      def update_agent_status: (
                                 instance_id: ::String,
                                 agent_status_id: ::String,
                                 ?name: ::String,
                                 ?description: ::String,
                                 ?state: ("ENABLED" | "DISABLED"),
                                 ?display_order: ::Integer,
                                 ?reset_order_number: bool
                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_authentication_profile-instance_method
      def update_authentication_profile: (
                                           authentication_profile_id: ::String,
                                           instance_id: ::String,
                                           ?name: ::String,
                                           ?description: ::String,
                                           ?allowed_ips: Array[::String],
                                           ?blocked_ips: Array[::String],
                                           ?periodic_session_duration: ::Integer
                                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateContactResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact-instance_method
      def update_contact: (
                            instance_id: ::String,
                            contact_id: ::String,
                            ?name: ::String,
                            ?description: ::String,
                            ?references: Hash[::String, {
                                value: ::String?,
                                type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                arn: ::String?,
                                status_reason: ::String?
                              }],
                            ?segment_attributes: Hash[::String, {
                                value_string: ::String?,
                                value_map: Hash[::String, untyped]?,
                                value_integer: ::Integer?
                              }],
                            ?queue_info: {
                              id: ::String?
                            },
                            ?user_info: {
                              user_id: ::String?
                            },
                            ?customer_endpoint: {
                              type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                              address: ::String?
                            },
                            ?system_endpoint: {
                              type: ("TELEPHONE_NUMBER" | "VOIP" | "CONTACT_FLOW" | "CONNECT_PHONENUMBER_ARN" | "EMAIL_ADDRESS")?,
                              address: ::String?
                            }
                          ) -> _UpdateContactResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactResponseSuccess

      interface _UpdateContactAttributesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactAttributesResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_attributes-instance_method
      def update_contact_attributes: (
                                       initial_contact_id: ::String,
                                       instance_id: ::String,
                                       attributes: Hash[::String, ::String]
                                     ) -> _UpdateContactAttributesResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactAttributesResponseSuccess

      interface _UpdateContactEvaluationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactEvaluationResponse]
        def evaluation_id: () -> ::String
        def evaluation_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_evaluation-instance_method
      def update_contact_evaluation: (
                                       instance_id: ::String,
                                       evaluation_id: ::String,
                                       ?answers: Hash[::String, {
                                           value: {
                                             string_value: ::String?,
                                             numeric_value: ::Float?,
                                             not_applicable: bool?
                                           }?
                                         }],
                                       ?notes: Hash[::String, {
                                           value: ::String?
                                         }]
                                     ) -> _UpdateContactEvaluationResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactEvaluationResponseSuccess

      interface _UpdateContactFlowContentResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactFlowContentResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_flow_content-instance_method
      def update_contact_flow_content: (
                                         instance_id: ::String,
                                         contact_flow_id: ::String,
                                         content: ::String
                                       ) -> _UpdateContactFlowContentResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactFlowContentResponseSuccess

      interface _UpdateContactFlowMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactFlowMetadataResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_flow_metadata-instance_method
      def update_contact_flow_metadata: (
                                          instance_id: ::String,
                                          contact_flow_id: ::String,
                                          ?name: ::String,
                                          ?description: ::String,
                                          ?contact_flow_state: ("ACTIVE" | "ARCHIVED")
                                        ) -> _UpdateContactFlowMetadataResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactFlowMetadataResponseSuccess

      interface _UpdateContactFlowModuleContentResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactFlowModuleContentResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_flow_module_content-instance_method
      def update_contact_flow_module_content: (
                                                instance_id: ::String,
                                                contact_flow_module_id: ::String,
                                                content: ::String
                                              ) -> _UpdateContactFlowModuleContentResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactFlowModuleContentResponseSuccess

      interface _UpdateContactFlowModuleMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactFlowModuleMetadataResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_flow_module_metadata-instance_method
      def update_contact_flow_module_metadata: (
                                                 instance_id: ::String,
                                                 contact_flow_module_id: ::String,
                                                 ?name: ::String,
                                                 ?description: ::String,
                                                 ?state: ("ACTIVE" | "ARCHIVED")
                                               ) -> _UpdateContactFlowModuleMetadataResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactFlowModuleMetadataResponseSuccess

      interface _UpdateContactFlowNameResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactFlowNameResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_flow_name-instance_method
      def update_contact_flow_name: (
                                      instance_id: ::String,
                                      contact_flow_id: ::String,
                                      ?name: ::String,
                                      ?description: ::String
                                    ) -> _UpdateContactFlowNameResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactFlowNameResponseSuccess

      interface _UpdateContactRoutingDataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactRoutingDataResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_routing_data-instance_method
      def update_contact_routing_data: (
                                         instance_id: ::String,
                                         contact_id: ::String,
                                         ?queue_time_adjustment_seconds: ::Integer,
                                         ?queue_priority: ::Integer,
                                         ?routing_criteria: {
                                           steps: Array[
                                             {
                                               expiry: {
                                                 duration_in_seconds: ::Integer?
                                               }?,
                                               expression: {
                                                 attribute_condition: {
                                                   name: ::String?,
                                                   value: ::String?,
                                                   proficiency_level: ::Float?,
                                                   range: {
                                                     min_proficiency_level: ::Float?,
                                                     max_proficiency_level: ::Float?
                                                   }?,
                                                   match_criteria: {
                                                     agents_criteria: {
                                                       agent_ids: Array[::String]?
                                                     }?
                                                   }?,
                                                   comparison_operator: ::String?
                                                 }?,
                                                 and_expression: Array[
                                                   untyped,
                                                 ]?,
                                                 or_expression: Array[
                                                   untyped,
                                                 ]?,
                                                 not_attribute_condition: {
                                                   name: ::String?,
                                                   value: ::String?,
                                                   proficiency_level: ::Float?,
                                                   range: {
                                                     min_proficiency_level: ::Float?,
                                                     max_proficiency_level: ::Float?
                                                   }?,
                                                   match_criteria: {
                                                     agents_criteria: {
                                                       agent_ids: Array[::String]?
                                                     }?
                                                   }?,
                                                   comparison_operator: ::String?
                                                 }?
                                               }?
                                             },
                                           ]?
                                         }
                                       ) -> _UpdateContactRoutingDataResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactRoutingDataResponseSuccess

      interface _UpdateContactScheduleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateContactScheduleResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_contact_schedule-instance_method
      def update_contact_schedule: (
                                     instance_id: ::String,
                                     contact_id: ::String,
                                     scheduled_time: ::Time
                                   ) -> _UpdateContactScheduleResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateContactScheduleResponseSuccess

      interface _UpdateEmailAddressMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateEmailAddressMetadataResponse]
        def email_address_id: () -> ::String
        def email_address_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_email_address_metadata-instance_method
      def update_email_address_metadata: (
                                           instance_id: ::String,
                                           email_address_id: ::String,
                                           ?description: ::String,
                                           ?display_name: ::String,
                                           ?client_token: ::String
                                         ) -> _UpdateEmailAddressMetadataResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateEmailAddressMetadataResponseSuccess

      interface _UpdateEvaluationFormResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateEvaluationFormResponse]
        def evaluation_form_id: () -> ::String
        def evaluation_form_arn: () -> ::String
        def evaluation_form_version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_evaluation_form-instance_method
      def update_evaluation_form: (
                                    instance_id: ::String,
                                    evaluation_form_id: ::String,
                                    evaluation_form_version: ::Integer,
                                    ?create_new_version: bool,
                                    title: ::String,
                                    ?description: ::String,
                                    items: Array[
                                      {
                                        section: {
                                          title: ::String,
                                          ref_id: ::String,
                                          instructions: ::String?,
                                          items: untyped,
                                          weight: ::Float?
                                        }?,
                                        question: {
                                          title: ::String,
                                          instructions: ::String?,
                                          ref_id: ::String,
                                          not_applicable_enabled: bool?,
                                          question_type: ("TEXT" | "SINGLESELECT" | "NUMERIC"),
                                          question_type_properties: {
                                            numeric: {
                                              min_value: ::Integer,
                                              max_value: ::Integer,
                                              options: Array[
                                                {
                                                  min_value: ::Integer,
                                                  max_value: ::Integer,
                                                  score: ::Integer?,
                                                  automatic_fail: bool?
                                                },
                                              ]?,
                                              automation: {
                                                property_value: {
                                                  label: ("OVERALL_CUSTOMER_SENTIMENT_SCORE" | "OVERALL_AGENT_SENTIMENT_SCORE" | "NON_TALK_TIME" | "NON_TALK_TIME_PERCENTAGE" | "NUMBER_OF_INTERRUPTIONS" | "CONTACT_DURATION" | "AGENT_INTERACTION_DURATION" | "CUSTOMER_HOLD_TIME")
                                                }?
                                              }?
                                            }?,
                                            single_select: {
                                              options: Array[
                                                {
                                                  ref_id: ::String,
                                                  text: ::String,
                                                  score: ::Integer?,
                                                  automatic_fail: bool?
                                                },
                                              ],
                                              display_as: ("DROPDOWN" | "RADIO")?,
                                              automation: {
                                                options: Array[
                                                  {
                                                    rule_category: {
                                                      category: ::String,
                                                      condition: ("PRESENT" | "NOT_PRESENT"),
                                                      option_ref_id: ::String
                                                    }?
                                                  },
                                                ],
                                                default_option_ref_id: ::String?
                                              }?
                                            }?
                                          }?,
                                          weight: ::Float?
                                        }?
                                      },
                                    ],
                                    ?scoring_strategy: {
                                      mode: ("QUESTION_ONLY" | "SECTION_ONLY"),
                                      status: ("ENABLED" | "DISABLED")
                                    },
                                    ?client_token: ::String
                                  ) -> _UpdateEvaluationFormResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateEvaluationFormResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_hours_of_operation-instance_method
      def update_hours_of_operation: (
                                       instance_id: ::String,
                                       hours_of_operation_id: ::String,
                                       ?name: ::String,
                                       ?description: ::String,
                                       ?time_zone: ::String,
                                       ?config: Array[
                                         {
                                           day: ("SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY"),
                                           start_time: {
                                             hours: ::Integer,
                                             minutes: ::Integer
                                           },
                                           end_time: {
                                             hours: ::Integer,
                                             minutes: ::Integer
                                           }
                                         },
                                       ]
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_hours_of_operation_override-instance_method
      def update_hours_of_operation_override: (
                                                instance_id: ::String,
                                                hours_of_operation_id: ::String,
                                                hours_of_operation_override_id: ::String,
                                                ?name: ::String,
                                                ?description: ::String,
                                                ?config: Array[
                                                  {
                                                    day: ("SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY")?,
                                                    start_time: {
                                                      hours: ::Integer,
                                                      minutes: ::Integer
                                                    }?,
                                                    end_time: {
                                                      hours: ::Integer,
                                                      minutes: ::Integer
                                                    }?
                                                  },
                                                ],
                                                ?effective_from: ::String,
                                                ?effective_till: ::String
                                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_instance_attribute-instance_method
      def update_instance_attribute: (
                                       instance_id: ::String,
                                       attribute_type: ("INBOUND_CALLS" | "OUTBOUND_CALLS" | "CONTACTFLOW_LOGS" | "CONTACT_LENS" | "AUTO_RESOLVE_BEST_VOICES" | "USE_CUSTOM_TTS_VOICES" | "EARLY_MEDIA" | "MULTI_PARTY_CONFERENCE" | "HIGH_VOLUME_OUTBOUND" | "ENHANCED_CONTACT_MONITORING" | "ENHANCED_CHAT_MONITORING" | "MULTI_PARTY_CHAT_CONFERENCE"),
                                       value: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_instance_storage_config-instance_method
      def update_instance_storage_config: (
                                            instance_id: ::String,
                                            association_id: ::String,
                                            resource_type: ("CHAT_TRANSCRIPTS" | "CALL_RECORDINGS" | "SCHEDULED_REPORTS" | "MEDIA_STREAMS" | "CONTACT_TRACE_RECORDS" | "AGENT_EVENTS" | "REAL_TIME_CONTACT_ANALYSIS_SEGMENTS" | "ATTACHMENTS" | "CONTACT_EVALUATIONS" | "SCREEN_RECORDINGS" | "REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS" | "REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS" | "EMAIL_MESSAGES"),
                                            storage_config: {
                                              association_id: ::String?,
                                              storage_type: ("S3" | "KINESIS_VIDEO_STREAM" | "KINESIS_STREAM" | "KINESIS_FIREHOSE"),
                                              s3_config: {
                                                bucket_name: ::String,
                                                bucket_prefix: ::String,
                                                encryption_config: {
                                                  encryption_type: ("KMS"),
                                                  key_id: ::String
                                                }?
                                              }?,
                                              kinesis_video_stream_config: {
                                                prefix: ::String,
                                                retention_period_hours: ::Integer,
                                                encryption_config: {
                                                  encryption_type: ("KMS"),
                                                  key_id: ::String
                                                }
                                              }?,
                                              kinesis_stream_config: {
                                                stream_arn: ::String
                                              }?,
                                              kinesis_firehose_config: {
                                                firehose_arn: ::String
                                              }?
                                            }
                                          ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateParticipantAuthenticationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateParticipantAuthenticationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_participant_authentication-instance_method
      def update_participant_authentication: (
                                               state: ::String,
                                               instance_id: ::String,
                                               ?code: ::String,
                                               ?error: ::String,
                                               ?error_description: ::String
                                             ) -> _UpdateParticipantAuthenticationResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateParticipantAuthenticationResponseSuccess

      interface _UpdateParticipantRoleConfigResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateParticipantRoleConfigResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_participant_role_config-instance_method
      def update_participant_role_config: (
                                            instance_id: ::String,
                                            contact_id: ::String,
                                            channel_configuration: {
                                              chat: {
                                                participant_timer_config_list: Array[
                                                  {
                                                    participant_role: ("CUSTOMER" | "AGENT"),
                                                    timer_type: ("IDLE" | "DISCONNECT_NONCUSTOMER"),
                                                    timer_value: {
                                                      participant_timer_action: ("Unset")?,
                                                      participant_timer_duration_in_minutes: ::Integer?
                                                    }
                                                  },
                                                ]
                                              }?
                                            }
                                          ) -> _UpdateParticipantRoleConfigResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateParticipantRoleConfigResponseSuccess

      interface _UpdatePhoneNumberResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePhoneNumberResponse]
        def phone_number_id: () -> ::String
        def phone_number_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_phone_number-instance_method
      def update_phone_number: (
                                 phone_number_id: ::String,
                                 ?target_arn: ::String,
                                 ?instance_id: ::String,
                                 ?client_token: ::String
                               ) -> _UpdatePhoneNumberResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePhoneNumberResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_phone_number_metadata-instance_method
      def update_phone_number_metadata: (
                                          phone_number_id: ::String,
                                          ?phone_number_description: ::String,
                                          ?client_token: ::String
                                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_predefined_attribute-instance_method
      def update_predefined_attribute: (
                                         instance_id: ::String,
                                         name: ::String,
                                         ?values: {
                                           string_list: Array[::String]?
                                         }
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdatePromptResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePromptResponse]
        def prompt_arn: () -> ::String
        def prompt_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_prompt-instance_method
      def update_prompt: (
                           instance_id: ::String,
                           prompt_id: ::String,
                           ?name: ::String,
                           ?description: ::String,
                           ?s3_uri: ::String
                         ) -> _UpdatePromptResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePromptResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_hours_of_operation-instance_method
      def update_queue_hours_of_operation: (
                                             instance_id: ::String,
                                             queue_id: ::String,
                                             hours_of_operation_id: ::String
                                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_max_contacts-instance_method
      def update_queue_max_contacts: (
                                       instance_id: ::String,
                                       queue_id: ::String,
                                       ?max_contacts: ::Integer
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_name-instance_method
      def update_queue_name: (
                               instance_id: ::String,
                               queue_id: ::String,
                               ?name: ::String,
                               ?description: ::String
                             ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_outbound_caller_config-instance_method
      def update_queue_outbound_caller_config: (
                                                 instance_id: ::String,
                                                 queue_id: ::String,
                                                 outbound_caller_config: {
                                                   outbound_caller_id_name: ::String?,
                                                   outbound_caller_id_number_id: ::String?,
                                                   outbound_flow_id: ::String?
                                                 }
                                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_outbound_email_config-instance_method
      def update_queue_outbound_email_config: (
                                                instance_id: ::String,
                                                queue_id: ::String,
                                                outbound_email_config: {
                                                  outbound_email_address_id: ::String?
                                                }
                                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_queue_status-instance_method
      def update_queue_status: (
                                 instance_id: ::String,
                                 queue_id: ::String,
                                 status: ("ENABLED" | "DISABLED")
                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_quick_connect_config-instance_method
      def update_quick_connect_config: (
                                         instance_id: ::String,
                                         quick_connect_id: ::String,
                                         quick_connect_config: {
                                           quick_connect_type: ("USER" | "QUEUE" | "PHONE_NUMBER"),
                                           user_config: {
                                             user_id: ::String,
                                             contact_flow_id: ::String
                                           }?,
                                           queue_config: {
                                             queue_id: ::String,
                                             contact_flow_id: ::String
                                           }?,
                                           phone_config: {
                                             phone_number: ::String
                                           }?
                                         }
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_quick_connect_name-instance_method
      def update_quick_connect_name: (
                                       instance_id: ::String,
                                       quick_connect_id: ::String,
                                       ?name: ::String,
                                       ?description: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_routing_profile_agent_availability_timer-instance_method
      def update_routing_profile_agent_availability_timer: (
                                                             instance_id: ::String,
                                                             routing_profile_id: ::String,
                                                             agent_availability_timer: ("TIME_SINCE_LAST_ACTIVITY" | "TIME_SINCE_LAST_INBOUND")
                                                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_routing_profile_concurrency-instance_method
      def update_routing_profile_concurrency: (
                                                instance_id: ::String,
                                                routing_profile_id: ::String,
                                                media_concurrencies: Array[
                                                  {
                                                    channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL"),
                                                    concurrency: ::Integer,
                                                    cross_channel_behavior: {
                                                      behavior_type: ("ROUTE_CURRENT_CHANNEL_ONLY" | "ROUTE_ANY_CHANNEL")
                                                    }?
                                                  },
                                                ]
                                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_routing_profile_default_outbound_queue-instance_method
      def update_routing_profile_default_outbound_queue: (
                                                           instance_id: ::String,
                                                           routing_profile_id: ::String,
                                                           default_outbound_queue_id: ::String
                                                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_routing_profile_name-instance_method
      def update_routing_profile_name: (
                                         instance_id: ::String,
                                         routing_profile_id: ::String,
                                         ?name: ::String,
                                         ?description: ::String
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_routing_profile_queues-instance_method
      def update_routing_profile_queues: (
                                           instance_id: ::String,
                                           routing_profile_id: ::String,
                                           queue_configs: Array[
                                             {
                                               queue_reference: {
                                                 queue_id: ::String,
                                                 channel: ("VOICE" | "CHAT" | "TASK" | "EMAIL")
                                               },
                                               priority: ::Integer,
                                               delay: ::Integer
                                             },
                                           ]
                                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_rule-instance_method
      def update_rule: (
                         rule_id: ::String,
                         instance_id: ::String,
                         name: ::String,
                         function: ::String,
                         actions: Array[
                           {
                             action_type: ("CREATE_TASK" | "ASSIGN_CONTACT_CATEGORY" | "GENERATE_EVENTBRIDGE_EVENT" | "SEND_NOTIFICATION" | "CREATE_CASE" | "UPDATE_CASE" | "END_ASSOCIATED_TASKS" | "SUBMIT_AUTO_EVALUATION"),
                             task_action: {
                               name: ::String,
                               description: ::String?,
                               contact_flow_id: ::String,
                               references: Hash[::String, {
                                   value: ::String?,
                                   type: ("URL" | "ATTACHMENT" | "CONTACT_ANALYSIS" | "NUMBER" | "STRING" | "DATE" | "EMAIL" | "EMAIL_MESSAGE"),
                                   status: ("AVAILABLE" | "DELETED" | "APPROVED" | "REJECTED" | "PROCESSING" | "FAILED")?,
                                   arn: ::String?,
                                   status_reason: ::String?
                                 }]?
                             }?,
                             event_bridge_action: {
                               name: ::String
                             }?,
                             assign_contact_category_action: {
                             }?,
                             send_notification_action: {
                               delivery_method: ("EMAIL"),
                               subject: ::String?,
                               content: ::String,
                               content_type: ("PLAIN_TEXT"),
                               recipient: {
                                 user_tags: Hash[::String, ::String]?,
                                 user_ids: Array[::String]?
                               }
                             }?,
                             create_case_action: {
                               fields: Array[
                                 {
                                   id: ::String,
                                   value: {
                                     boolean_value: bool?,
                                     double_value: ::Float?,
                                     empty_value: {
                                     }?,
                                     string_value: ::String?
                                   }
                                 },
                               ],
                               template_id: ::String
                             }?,
                             update_case_action: {
                               fields: Array[
                                 {
                                   id: ::String,
                                   value: {
                                     boolean_value: bool?,
                                     double_value: ::Float?,
                                     empty_value: {
                                     }?,
                                     string_value: ::String?
                                   }
                                 },
                               ]
                             }?,
                             end_associated_tasks_action: {
                             }?,
                             submit_auto_evaluation_action: {
                               evaluation_form_id: ::String
                             }?
                           },
                         ],
                         publish_status: ("DRAFT" | "PUBLISHED")
                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_security_profile-instance_method
      def update_security_profile: (
                                     ?description: ::String,
                                     ?permissions: Array[::String],
                                     security_profile_id: ::String,
                                     instance_id: ::String,
                                     ?allowed_access_control_tags: Hash[::String, ::String],
                                     ?tag_restricted_resources: Array[::String],
                                     ?applications: Array[
                                       {
                                         namespace: ::String?,
                                         application_permissions: Array[::String]?
                                       },
                                     ],
                                     ?hierarchy_restricted_resources: Array[::String],
                                     ?allowed_access_control_hierarchy_group_id: ::String
                                   ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateTaskTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTaskTemplateResponse]
        def instance_id: () -> ::String
        def id: () -> ::String
        def arn: () -> ::String
        def name: () -> ::String
        def description: () -> ::String
        def contact_flow_id: () -> ::String
        def self_assign_flow_id: () -> ::String
        def constraints: () -> Types::TaskTemplateConstraints
        def defaults: () -> Types::TaskTemplateDefaults
        def fields: () -> ::Array[Types::TaskTemplateField]
        def status: () -> ("ACTIVE" | "INACTIVE")
        def last_modified_time: () -> ::Time
        def created_time: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_task_template-instance_method
      def update_task_template: (
                                  task_template_id: ::String,
                                  instance_id: ::String,
                                  ?name: ::String,
                                  ?description: ::String,
                                  ?contact_flow_id: ::String,
                                  ?self_assign_flow_id: ::String,
                                  ?constraints: {
                                    required_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?,
                                    read_only_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?,
                                    invisible_fields: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?
                                      },
                                    ]?
                                  },
                                  ?defaults: {
                                    default_field_values: Array[
                                      {
                                        id: {
                                          name: ::String?
                                        }?,
                                        default_value: ::String?
                                      },
                                    ]?
                                  },
                                  ?status: ("ACTIVE" | "INACTIVE"),
                                  ?fields: Array[
                                    {
                                      id: {
                                        name: ::String?
                                      },
                                      description: ::String?,
                                      type: ("NAME" | "DESCRIPTION" | "SCHEDULED_TIME" | "QUICK_CONNECT" | "URL" | "NUMBER" | "TEXT" | "TEXT_AREA" | "DATE_TIME" | "BOOLEAN" | "SINGLE_SELECT" | "EMAIL" | "SELF_ASSIGN" | "EXPIRY_DURATION")?,
                                      single_select_options: Array[::String]?
                                    },
                                  ]
                                ) -> _UpdateTaskTemplateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTaskTemplateResponseSuccess

      interface _UpdateTrafficDistributionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTrafficDistributionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_traffic_distribution-instance_method
      def update_traffic_distribution: (
                                         id: ::String,
                                         ?telephony_config: {
                                           distributions: Array[
                                             {
                                               region: ::String,
                                               percentage: ::Integer
                                             },
                                           ]
                                         },
                                         ?sign_in_config: {
                                           distributions: Array[
                                             {
                                               region: ::String,
                                               enabled: bool
                                             },
                                           ]
                                         },
                                         ?agent_config: {
                                           distributions: Array[
                                             {
                                               region: ::String,
                                               percentage: ::Integer
                                             },
                                           ]
                                         }
                                       ) -> _UpdateTrafficDistributionResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTrafficDistributionResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_hierarchy-instance_method
      def update_user_hierarchy: (
                                   ?hierarchy_group_id: ::String,
                                   user_id: ::String,
                                   instance_id: ::String
                                 ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_hierarchy_group_name-instance_method
      def update_user_hierarchy_group_name: (
                                              name: ::String,
                                              hierarchy_group_id: ::String,
                                              instance_id: ::String
                                            ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_hierarchy_structure-instance_method
      def update_user_hierarchy_structure: (
                                             hierarchy_structure: {
                                               level_one: {
                                                 name: ::String
                                               }?,
                                               level_two: {
                                                 name: ::String
                                               }?,
                                               level_three: {
                                                 name: ::String
                                               }?,
                                               level_four: {
                                                 name: ::String
                                               }?,
                                               level_five: {
                                                 name: ::String
                                               }?
                                             },
                                             instance_id: ::String
                                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_identity_info-instance_method
      def update_user_identity_info: (
                                       identity_info: {
                                         first_name: ::String?,
                                         last_name: ::String?,
                                         email: ::String?,
                                         secondary_email: ::String?,
                                         mobile: ::String?
                                       },
                                       user_id: ::String,
                                       instance_id: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_phone_config-instance_method
      def update_user_phone_config: (
                                      phone_config: {
                                        phone_type: ("SOFT_PHONE" | "DESK_PHONE"),
                                        auto_accept: bool?,
                                        after_contact_work_time_limit: ::Integer?,
                                        desk_phone_number: ::String?
                                      },
                                      user_id: ::String,
                                      instance_id: ::String
                                    ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_proficiencies-instance_method
      def update_user_proficiencies: (
                                       instance_id: ::String,
                                       user_id: ::String,
                                       user_proficiencies: Array[
                                         {
                                           attribute_name: ::String,
                                           attribute_value: ::String,
                                           level: ::Float
                                         },
                                       ]
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_routing_profile-instance_method
      def update_user_routing_profile: (
                                         routing_profile_id: ::String,
                                         user_id: ::String,
                                         instance_id: ::String
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_user_security_profiles-instance_method
      def update_user_security_profiles: (
                                           security_profile_ids: Array[::String],
                                           user_id: ::String,
                                           instance_id: ::String
                                         ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateViewContentResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateViewContentResponse]
        def view: () -> Types::View
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_view_content-instance_method
      def update_view_content: (
                                 instance_id: ::String,
                                 view_id: ::String,
                                 status: ("PUBLISHED" | "SAVED"),
                                 content: {
                                   template: ::String?,
                                   actions: Array[::String]?
                                 }
                               ) -> _UpdateViewContentResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateViewContentResponseSuccess

      interface _UpdateViewMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateViewMetadataResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Connect/Client.html#update_view_metadata-instance_method
      def update_view_metadata: (
                                  instance_id: ::String,
                                  view_id: ::String,
                                  ?name: ::String,
                                  ?description: ::String
                                ) -> _UpdateViewMetadataResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateViewMetadataResponseSuccess
    end
  end
end