# 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 IoT
    class Client < ::Seahorse::Client::Base
      include ::Aws::ClientStubs

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/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


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

      interface _AddThingToBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AddThingToBillingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#add_thing_to_billing_group-instance_method
      def add_thing_to_billing_group: (
                                        ?billing_group_name: ::String,
                                        ?billing_group_arn: ::String,
                                        ?thing_name: ::String,
                                        ?thing_arn: ::String
                                      ) -> _AddThingToBillingGroupResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AddThingToBillingGroupResponseSuccess

      interface _AddThingToThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AddThingToThingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#add_thing_to_thing_group-instance_method
      def add_thing_to_thing_group: (
                                      ?thing_group_name: ::String,
                                      ?thing_group_arn: ::String,
                                      ?thing_name: ::String,
                                      ?thing_arn: ::String,
                                      ?override_dynamic_groups: bool
                                    ) -> _AddThingToThingGroupResponseSuccess
                                  | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AddThingToThingGroupResponseSuccess

      interface _AssociateSbomWithPackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateSbomWithPackageVersionResponse]
        def package_name: () -> ::String
        def version_name: () -> ::String
        def sbom: () -> Types::Sbom
        def sbom_validation_status: () -> ("IN_PROGRESS" | "FAILED" | "SUCCEEDED")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#associate_sbom_with_package_version-instance_method
      def associate_sbom_with_package_version: (
                                                 package_name: ::String,
                                                 version_name: ::String,
                                                 sbom: {
                                                   s3_location: {
                                                     bucket: ::String?,
                                                     key: ::String?,
                                                     version: ::String?
                                                   }?
                                                 },
                                                 ?client_token: ::String
                                               ) -> _AssociateSbomWithPackageVersionResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateSbomWithPackageVersionResponseSuccess

      interface _AssociateTargetsWithJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AssociateTargetsWithJobResponse]
        def job_arn: () -> ::String
        def job_id: () -> ::String
        def description: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#associate_targets_with_job-instance_method
      def associate_targets_with_job: (
                                        targets: Array[::String],
                                        job_id: ::String,
                                        ?comment: ::String,
                                        ?namespace_id: ::String
                                      ) -> _AssociateTargetsWithJobResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AssociateTargetsWithJobResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#attach_policy-instance_method
      def attach_policy: (
                           policy_name: ::String,
                           target: ::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/IoT/Client.html#attach_principal_policy-instance_method
      def attach_principal_policy: (
                                     policy_name: ::String,
                                     principal: ::String
                                   ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _AttachSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AttachSecurityProfileResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#attach_security_profile-instance_method
      def attach_security_profile: (
                                     security_profile_name: ::String,
                                     security_profile_target_arn: ::String
                                   ) -> _AttachSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AttachSecurityProfileResponseSuccess

      interface _AttachThingPrincipalResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AttachThingPrincipalResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#attach_thing_principal-instance_method
      def attach_thing_principal: (
                                    thing_name: ::String,
                                    principal: ::String,
                                    ?thing_principal_type: ("EXCLUSIVE_THING" | "NON_EXCLUSIVE_THING")
                                  ) -> _AttachThingPrincipalResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AttachThingPrincipalResponseSuccess

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

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

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

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

      interface _CancelJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CancelJobResponse]
        def job_arn: () -> ::String
        def job_id: () -> ::String
        def description: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#cancel_job-instance_method
      def cancel_job: (
                        job_id: ::String,
                        ?reason_code: ::String,
                        ?comment: ::String,
                        ?force: bool
                      ) -> _CancelJobResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CancelJobResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#cancel_job_execution-instance_method
      def cancel_job_execution: (
                                  job_id: ::String,
                                  thing_name: ::String,
                                  ?force: bool,
                                  ?expected_version: ::Integer,
                                  ?status_details: Hash[::String, ::String]
                                ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _ClearDefaultAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ClearDefaultAuthorizerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#clear_default_authorizer-instance_method
      def clear_default_authorizer: (
                                    ) -> _ClearDefaultAuthorizerResponseSuccess
                                  | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ClearDefaultAuthorizerResponseSuccess

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

      interface _CreateAuditSuppressionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateAuditSuppressionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_audit_suppression-instance_method
      def create_audit_suppression: (
                                      check_name: ::String,
                                      resource_identifier: {
                                        device_certificate_id: ::String?,
                                        ca_certificate_id: ::String?,
                                        cognito_identity_pool_id: ::String?,
                                        client_id: ::String?,
                                        policy_version_identifier: {
                                          policy_name: ::String?,
                                          policy_version_id: ::String?
                                        }?,
                                        account: ::String?,
                                        iam_role_arn: ::String?,
                                        role_alias_arn: ::String?,
                                        issuer_certificate_identifier: {
                                          issuer_certificate_subject: ::String?,
                                          issuer_id: ::String?,
                                          issuer_certificate_serial_number: ::String?
                                        }?,
                                        device_certificate_arn: ::String?
                                      },
                                      ?expiration_date: ::Time,
                                      ?suppress_indefinitely: bool,
                                      ?description: ::String,
                                      client_request_token: ::String
                                    ) -> _CreateAuditSuppressionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateAuditSuppressionResponseSuccess

      interface _CreateAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateAuthorizerResponse]
        def authorizer_name: () -> ::String
        def authorizer_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_authorizer-instance_method
      def create_authorizer: (
                               authorizer_name: ::String,
                               authorizer_function_arn: ::String,
                               ?token_key_name: ::String,
                               ?token_signing_public_keys: Hash[::String, ::String],
                               ?status: ("ACTIVE" | "INACTIVE"),
                               ?tags: Array[
                                 {
                                   key: ::String,
                                   value: ::String?
                                 },
                               ],
                               ?signing_disabled: bool,
                               ?enable_caching_for_http: bool
                             ) -> _CreateAuthorizerResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateAuthorizerResponseSuccess

      interface _CreateBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateBillingGroupResponse]
        def billing_group_name: () -> ::String
        def billing_group_arn: () -> ::String
        def billing_group_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_billing_group-instance_method
      def create_billing_group: (
                                  billing_group_name: ::String,
                                  ?billing_group_properties: {
                                    billing_group_description: ::String?
                                  },
                                  ?tags: Array[
                                    {
                                      key: ::String,
                                      value: ::String?
                                    },
                                  ]
                                ) -> _CreateBillingGroupResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateBillingGroupResponseSuccess

      interface _CreateCertificateFromCsrResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCertificateFromCsrResponse]
        def certificate_arn: () -> ::String
        def certificate_id: () -> ::String
        def certificate_pem: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_certificate_from_csr-instance_method
      def create_certificate_from_csr: (
                                         certificate_signing_request: ::String,
                                         ?set_as_active: bool
                                       ) -> _CreateCertificateFromCsrResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCertificateFromCsrResponseSuccess

      interface _CreateCertificateProviderResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCertificateProviderResponse]
        def certificate_provider_name: () -> ::String
        def certificate_provider_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_certificate_provider-instance_method
      def create_certificate_provider: (
                                         certificate_provider_name: ::String,
                                         lambda_function_arn: ::String,
                                         account_default_for_operations: Array[("CreateCertificateFromCsr")],
                                         ?client_token: ::String,
                                         ?tags: Array[
                                           {
                                             key: ::String,
                                             value: ::String?
                                           },
                                         ]
                                       ) -> _CreateCertificateProviderResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCertificateProviderResponseSuccess

      interface _CreateCommandResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCommandResponse]
        def command_id: () -> ::String
        def command_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_command-instance_method
      def create_command: (
                            command_id: ::String,
                            ?namespace: ("AWS-IoT" | "AWS-IoT-FleetWise"),
                            ?display_name: ::String,
                            ?description: ::String,
                            ?payload: {
                              content: ::String?,
                              content_type: ::String?
                            },
                            ?mandatory_parameters: Array[
                              {
                                name: ::String,
                                value: {
                                  s: ::String?,
                                  b: bool?,
                                  i: ::Integer?,
                                  l: ::Integer?,
                                  d: ::Float?,
                                  bin: ::String?,
                                  ul: ::String?
                                }?,
                                default_value: {
                                  s: ::String?,
                                  b: bool?,
                                  i: ::Integer?,
                                  l: ::Integer?,
                                  d: ::Float?,
                                  bin: ::String?,
                                  ul: ::String?
                                }?,
                                description: ::String?
                              },
                            ],
                            ?role_arn: ::String,
                            ?tags: Array[
                              {
                                key: ::String,
                                value: ::String?
                              },
                            ]
                          ) -> _CreateCommandResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCommandResponseSuccess

      interface _CreateCustomMetricResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCustomMetricResponse]
        def metric_name: () -> ::String
        def metric_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_custom_metric-instance_method
      def create_custom_metric: (
                                  metric_name: ::String,
                                  ?display_name: ::String,
                                  metric_type: ("string-list" | "ip-address-list" | "number-list" | "number"),
                                  ?tags: Array[
                                    {
                                      key: ::String,
                                      value: ::String?
                                    },
                                  ],
                                  client_request_token: ::String
                                ) -> _CreateCustomMetricResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCustomMetricResponseSuccess

      interface _CreateDimensionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDimensionResponse]
        def name: () -> ::String
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_dimension-instance_method
      def create_dimension: (
                              name: ::String,
                              type: ("TOPIC_FILTER"),
                              string_values: Array[::String],
                              ?tags: Array[
                                {
                                  key: ::String,
                                  value: ::String?
                                },
                              ],
                              client_request_token: ::String
                            ) -> _CreateDimensionResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDimensionResponseSuccess

      interface _CreateDomainConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDomainConfigurationResponse]
        def domain_configuration_name: () -> ::String
        def domain_configuration_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_domain_configuration-instance_method
      def create_domain_configuration: (
                                         domain_configuration_name: ::String,
                                         ?domain_name: ::String,
                                         ?server_certificate_arns: Array[::String],
                                         ?validation_certificate_arn: ::String,
                                         ?authorizer_config: {
                                           default_authorizer_name: ::String?,
                                           allow_authorizer_override: bool?
                                         },
                                         ?service_type: ("DATA" | "CREDENTIAL_PROVIDER" | "JOBS"),
                                         ?tags: Array[
                                           {
                                             key: ::String,
                                             value: ::String?
                                           },
                                         ],
                                         ?tls_config: {
                                           security_policy: ::String?
                                         },
                                         ?server_certificate_config: {
                                           enable_ocsp_check: bool?,
                                           ocsp_lambda_arn: ::String?,
                                           ocsp_authorized_responder_arn: ::String?
                                         },
                                         ?authentication_type: ("CUSTOM_AUTH_X509" | "CUSTOM_AUTH" | "AWS_X509" | "AWS_SIGV4" | "DEFAULT"),
                                         ?application_protocol: ("SECURE_MQTT" | "MQTT_WSS" | "HTTPS" | "DEFAULT"),
                                         ?client_certificate_config: {
                                           client_certificate_callback_arn: ::String?
                                         }
                                       ) -> _CreateDomainConfigurationResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDomainConfigurationResponseSuccess

      interface _CreateDynamicThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDynamicThingGroupResponse]
        def thing_group_name: () -> ::String
        def thing_group_arn: () -> ::String
        def thing_group_id: () -> ::String
        def index_name: () -> ::String
        def query_string: () -> ::String
        def query_version: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_dynamic_thing_group-instance_method
      def create_dynamic_thing_group: (
                                        thing_group_name: ::String,
                                        ?thing_group_properties: {
                                          thing_group_description: ::String?,
                                          attribute_payload: {
                                            attributes: Hash[::String, ::String]?,
                                            merge: bool?
                                          }?
                                        },
                                        ?index_name: ::String,
                                        query_string: ::String,
                                        ?query_version: ::String,
                                        ?tags: Array[
                                          {
                                            key: ::String,
                                            value: ::String?
                                          },
                                        ]
                                      ) -> _CreateDynamicThingGroupResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDynamicThingGroupResponseSuccess

      interface _CreateFleetMetricResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateFleetMetricResponse]
        def metric_name: () -> ::String
        def metric_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_fleet_metric-instance_method
      def create_fleet_metric: (
                                 metric_name: ::String,
                                 query_string: ::String,
                                 aggregation_type: {
                                   name: ("Statistics" | "Percentiles" | "Cardinality"),
                                   values: Array[::String]?
                                 },
                                 period: ::Integer,
                                 aggregation_field: ::String,
                                 ?description: ::String,
                                 ?query_version: ::String,
                                 ?index_name: ::String,
                                 ?unit: ("Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second" | "None"),
                                 ?tags: Array[
                                   {
                                     key: ::String,
                                     value: ::String?
                                   },
                                 ]
                               ) -> _CreateFleetMetricResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateFleetMetricResponseSuccess

      interface _CreateJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateJobResponse]
        def job_arn: () -> ::String
        def job_id: () -> ::String
        def description: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_job-instance_method
      def create_job: (
                        job_id: ::String,
                        targets: Array[::String],
                        ?document_source: ::String,
                        ?document: ::String,
                        ?description: ::String,
                        ?presigned_url_config: {
                          role_arn: ::String?,
                          expires_in_sec: ::Integer?
                        },
                        ?target_selection: ("CONTINUOUS" | "SNAPSHOT"),
                        ?job_executions_rollout_config: {
                          maximum_per_minute: ::Integer?,
                          exponential_rate: {
                            base_rate_per_minute: ::Integer,
                            increment_factor: ::Float,
                            rate_increase_criteria: {
                              number_of_notified_things: ::Integer?,
                              number_of_succeeded_things: ::Integer?
                            }
                          }?
                        },
                        ?abort_config: {
                          criteria_list: Array[
                            {
                              failure_type: ("FAILED" | "REJECTED" | "TIMED_OUT" | "ALL"),
                              action: ("CANCEL"),
                              threshold_percentage: ::Float,
                              min_number_of_executed_things: ::Integer
                            },
                          ]
                        },
                        ?timeout_config: {
                          in_progress_timeout_in_minutes: ::Integer?
                        },
                        ?tags: Array[
                          {
                            key: ::String,
                            value: ::String?
                          },
                        ],
                        ?namespace_id: ::String,
                        ?job_template_arn: ::String,
                        ?job_executions_retry_config: {
                          criteria_list: Array[
                            {
                              failure_type: ("FAILED" | "TIMED_OUT" | "ALL"),
                              number_of_retries: ::Integer
                            },
                          ]
                        },
                        ?document_parameters: Hash[::String, ::String],
                        ?scheduling_config: {
                          start_time: ::String?,
                          end_time: ::String?,
                          end_behavior: ("STOP_ROLLOUT" | "CANCEL" | "FORCE_CANCEL")?,
                          maintenance_windows: Array[
                            {
                              start_time: ::String,
                              duration_in_minutes: ::Integer
                            },
                          ]?
                        },
                        ?destination_package_versions: Array[::String]
                      ) -> _CreateJobResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateJobResponseSuccess

      interface _CreateJobTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateJobTemplateResponse]
        def job_template_arn: () -> ::String
        def job_template_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_job_template-instance_method
      def create_job_template: (
                                 job_template_id: ::String,
                                 ?job_arn: ::String,
                                 ?document_source: ::String,
                                 ?document: ::String,
                                 description: ::String,
                                 ?presigned_url_config: {
                                   role_arn: ::String?,
                                   expires_in_sec: ::Integer?
                                 },
                                 ?job_executions_rollout_config: {
                                   maximum_per_minute: ::Integer?,
                                   exponential_rate: {
                                     base_rate_per_minute: ::Integer,
                                     increment_factor: ::Float,
                                     rate_increase_criteria: {
                                       number_of_notified_things: ::Integer?,
                                       number_of_succeeded_things: ::Integer?
                                     }
                                   }?
                                 },
                                 ?abort_config: {
                                   criteria_list: Array[
                                     {
                                       failure_type: ("FAILED" | "REJECTED" | "TIMED_OUT" | "ALL"),
                                       action: ("CANCEL"),
                                       threshold_percentage: ::Float,
                                       min_number_of_executed_things: ::Integer
                                     },
                                   ]
                                 },
                                 ?timeout_config: {
                                   in_progress_timeout_in_minutes: ::Integer?
                                 },
                                 ?tags: Array[
                                   {
                                     key: ::String,
                                     value: ::String?
                                   },
                                 ],
                                 ?job_executions_retry_config: {
                                   criteria_list: Array[
                                     {
                                       failure_type: ("FAILED" | "TIMED_OUT" | "ALL"),
                                       number_of_retries: ::Integer
                                     },
                                   ]
                                 },
                                 ?maintenance_windows: Array[
                                   {
                                     start_time: ::String,
                                     duration_in_minutes: ::Integer
                                   },
                                 ],
                                 ?destination_package_versions: Array[::String]
                               ) -> _CreateJobTemplateResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateJobTemplateResponseSuccess

      interface _CreateKeysAndCertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateKeysAndCertificateResponse]
        def certificate_arn: () -> ::String
        def certificate_id: () -> ::String
        def certificate_pem: () -> ::String
        def key_pair: () -> Types::KeyPair
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_keys_and_certificate-instance_method
      def create_keys_and_certificate: (
                                         ?set_as_active: bool
                                       ) -> _CreateKeysAndCertificateResponseSuccess
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateKeysAndCertificateResponseSuccess

      interface _CreateMitigationActionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateMitigationActionResponse]
        def action_arn: () -> ::String
        def action_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_mitigation_action-instance_method
      def create_mitigation_action: (
                                      action_name: ::String,
                                      role_arn: ::String,
                                      action_params: {
                                        update_device_certificate_params: {
                                          action: ("DEACTIVATE")
                                        }?,
                                        update_ca_certificate_params: {
                                          action: ("DEACTIVATE")
                                        }?,
                                        add_things_to_thing_group_params: {
                                          thing_group_names: Array[::String],
                                          override_dynamic_groups: bool?
                                        }?,
                                        replace_default_policy_version_params: {
                                          template_name: ("BLANK_POLICY")
                                        }?,
                                        enable_io_t_logging_params: {
                                          role_arn_for_logging: ::String,
                                          log_level: ("DEBUG" | "INFO" | "ERROR" | "WARN" | "DISABLED")
                                        }?,
                                        publish_finding_to_sns_params: {
                                          topic_arn: ::String
                                        }?
                                      },
                                      ?tags: Array[
                                        {
                                          key: ::String,
                                          value: ::String?
                                        },
                                      ]
                                    ) -> _CreateMitigationActionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateMitigationActionResponseSuccess

      interface _CreateOTAUpdateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateOTAUpdateResponse]
        def ota_update_id: () -> ::String
        def aws_iot_job_id: () -> ::String
        def ota_update_arn: () -> ::String
        def aws_iot_job_arn: () -> ::String
        def ota_update_status: () -> ("CREATE_PENDING" | "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "CREATE_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_FAILED")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_ota_update-instance_method
      def create_ota_update: (
                               ota_update_id: ::String,
                               ?description: ::String,
                               targets: Array[::String],
                               ?protocols: Array[("MQTT" | "HTTP")],
                               ?target_selection: ("CONTINUOUS" | "SNAPSHOT"),
                               ?aws_job_executions_rollout_config: {
                                 maximum_per_minute: ::Integer?,
                                 exponential_rate: {
                                   base_rate_per_minute: ::Integer,
                                   increment_factor: ::Float,
                                   rate_increase_criteria: {
                                     number_of_notified_things: ::Integer?,
                                     number_of_succeeded_things: ::Integer?
                                   }
                                 }?
                               },
                               ?aws_job_presigned_url_config: {
                                 expires_in_sec: ::Integer?
                               },
                               ?aws_job_abort_config: {
                                 abort_criteria_list: Array[
                                   {
                                     failure_type: ("FAILED" | "REJECTED" | "TIMED_OUT" | "ALL"),
                                     action: ("CANCEL"),
                                     threshold_percentage: ::Float,
                                     min_number_of_executed_things: ::Integer
                                   },
                                 ]
                               },
                               ?aws_job_timeout_config: {
                                 in_progress_timeout_in_minutes: ::Integer?
                               },
                               files: Array[
                                 {
                                   file_name: ::String?,
                                   file_type: ::Integer?,
                                   file_version: ::String?,
                                   file_location: {
                                     stream: {
                                       stream_id: ::String?,
                                       file_id: ::Integer?
                                     }?,
                                     s3_location: {
                                       bucket: ::String?,
                                       key: ::String?,
                                       version: ::String?
                                     }?
                                   }?,
                                   code_signing: {
                                     aws_signer_job_id: ::String?,
                                     start_signing_job_parameter: {
                                       signing_profile_parameter: {
                                         certificate_arn: ::String?,
                                         platform: ::String?,
                                         certificate_path_on_device: ::String?
                                       }?,
                                       signing_profile_name: ::String?,
                                       destination: {
                                         s3_destination: {
                                           bucket: ::String?,
                                           prefix: ::String?
                                         }?
                                       }?
                                     }?,
                                     custom_code_signing: {
                                       signature: {
                                         inline_document: ::String?
                                       }?,
                                       certificate_chain: {
                                         certificate_name: ::String?,
                                         inline_document: ::String?
                                       }?,
                                       hash_algorithm: ::String?,
                                       signature_algorithm: ::String?
                                     }?
                                   }?,
                                   attributes: Hash[::String, ::String]?
                                 },
                               ],
                               role_arn: ::String,
                               ?additional_parameters: Hash[::String, ::String],
                               ?tags: Array[
                                 {
                                   key: ::String,
                                   value: ::String?
                                 },
                               ]
                             ) -> _CreateOTAUpdateResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateOTAUpdateResponseSuccess

      interface _CreatePackageResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePackageResponse]
        def package_name: () -> ::String
        def package_arn: () -> ::String
        def description: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_package-instance_method
      def create_package: (
                            package_name: ::String,
                            ?description: ::String,
                            ?tags: Hash[::String, ::String],
                            ?client_token: ::String
                          ) -> _CreatePackageResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePackageResponseSuccess

      interface _CreatePackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePackageVersionResponse]
        def package_version_arn: () -> ::String
        def package_name: () -> ::String
        def version_name: () -> ::String
        def description: () -> ::String
        def attributes: () -> ::Hash[::String, ::String]
        def status: () -> ("DRAFT" | "PUBLISHED" | "DEPRECATED")
        def error_reason: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_package_version-instance_method
      def create_package_version: (
                                    package_name: ::String,
                                    version_name: ::String,
                                    ?description: ::String,
                                    ?attributes: Hash[::String, ::String],
                                    ?artifact: {
                                      s3_location: {
                                        bucket: ::String?,
                                        key: ::String?,
                                        version: ::String?
                                      }?
                                    },
                                    ?recipe: ::String,
                                    ?tags: Hash[::String, ::String],
                                    ?client_token: ::String
                                  ) -> _CreatePackageVersionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePackageVersionResponseSuccess

      interface _CreatePolicyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePolicyResponse]
        def policy_name: () -> ::String
        def policy_arn: () -> ::String
        def policy_document: () -> ::String
        def policy_version_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_policy-instance_method
      def create_policy: (
                           policy_name: ::String,
                           policy_document: ::String,
                           ?tags: Array[
                             {
                               key: ::String,
                               value: ::String?
                             },
                           ]
                         ) -> _CreatePolicyResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePolicyResponseSuccess

      interface _CreatePolicyVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePolicyVersionResponse]
        def policy_arn: () -> ::String
        def policy_document: () -> ::String
        def policy_version_id: () -> ::String
        def is_default_version: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_policy_version-instance_method
      def create_policy_version: (
                                   policy_name: ::String,
                                   policy_document: ::String,
                                   ?set_as_default: bool
                                 ) -> _CreatePolicyVersionResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePolicyVersionResponseSuccess

      interface _CreateProvisioningClaimResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateProvisioningClaimResponse]
        def certificate_id: () -> ::String
        def certificate_pem: () -> ::String
        def key_pair: () -> Types::KeyPair
        def expiration: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_provisioning_claim-instance_method
      def create_provisioning_claim: (
                                       template_name: ::String
                                     ) -> _CreateProvisioningClaimResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateProvisioningClaimResponseSuccess

      interface _CreateProvisioningTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateProvisioningTemplateResponse]
        def template_arn: () -> ::String
        def template_name: () -> ::String
        def default_version_id: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_provisioning_template-instance_method
      def create_provisioning_template: (
                                          template_name: ::String,
                                          ?description: ::String,
                                          template_body: ::String,
                                          ?enabled: bool,
                                          provisioning_role_arn: ::String,
                                          ?pre_provisioning_hook: {
                                            payload_version: ::String?,
                                            target_arn: ::String
                                          },
                                          ?tags: Array[
                                            {
                                              key: ::String,
                                              value: ::String?
                                            },
                                          ],
                                          ?type: ("FLEET_PROVISIONING" | "JITP")
                                        ) -> _CreateProvisioningTemplateResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateProvisioningTemplateResponseSuccess

      interface _CreateProvisioningTemplateVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateProvisioningTemplateVersionResponse]
        def template_arn: () -> ::String
        def template_name: () -> ::String
        def version_id: () -> ::Integer
        def is_default_version: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_provisioning_template_version-instance_method
      def create_provisioning_template_version: (
                                                  template_name: ::String,
                                                  template_body: ::String,
                                                  ?set_as_default: bool
                                                ) -> _CreateProvisioningTemplateVersionResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateProvisioningTemplateVersionResponseSuccess

      interface _CreateRoleAliasResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateRoleAliasResponse]
        def role_alias: () -> ::String
        def role_alias_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_role_alias-instance_method
      def create_role_alias: (
                               role_alias: ::String,
                               role_arn: ::String,
                               ?credential_duration_seconds: ::Integer,
                               ?tags: Array[
                                 {
                                   key: ::String,
                                   value: ::String?
                                 },
                               ]
                             ) -> _CreateRoleAliasResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateRoleAliasResponseSuccess

      interface _CreateScheduledAuditResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateScheduledAuditResponse]
        def scheduled_audit_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_scheduled_audit-instance_method
      def create_scheduled_audit: (
                                    frequency: ("DAILY" | "WEEKLY" | "BIWEEKLY" | "MONTHLY"),
                                    ?day_of_month: ::String,
                                    ?day_of_week: ("SUN" | "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT"),
                                    target_check_names: Array[::String],
                                    scheduled_audit_name: ::String,
                                    ?tags: Array[
                                      {
                                        key: ::String,
                                        value: ::String?
                                      },
                                    ]
                                  ) -> _CreateScheduledAuditResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateScheduledAuditResponseSuccess

      interface _CreateSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSecurityProfileResponse]
        def security_profile_name: () -> ::String
        def security_profile_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_security_profile-instance_method
      def create_security_profile: (
                                     security_profile_name: ::String,
                                     ?security_profile_description: ::String,
                                     ?behaviors: Array[
                                       {
                                         name: ::String,
                                         metric: ::String?,
                                         metric_dimension: {
                                           dimension_name: ::String,
                                           operator: ("IN" | "NOT_IN")?
                                         }?,
                                         criteria: {
                                           comparison_operator: ("less-than" | "less-than-equals" | "greater-than" | "greater-than-equals" | "in-cidr-set" | "not-in-cidr-set" | "in-port-set" | "not-in-port-set" | "in-set" | "not-in-set")?,
                                           value: {
                                             count: ::Integer?,
                                             cidrs: Array[::String]?,
                                             ports: Array[::Integer]?,
                                             number: ::Float?,
                                             numbers: Array[::Float]?,
                                             strings: Array[::String]?
                                           }?,
                                           duration_seconds: ::Integer?,
                                           consecutive_datapoints_to_alarm: ::Integer?,
                                           consecutive_datapoints_to_clear: ::Integer?,
                                           statistical_threshold: {
                                             statistic: ::String?
                                           }?,
                                           ml_detection_config: {
                                             confidence_level: ("LOW" | "MEDIUM" | "HIGH")
                                           }?
                                         }?,
                                         suppress_alerts: bool?,
                                         export_metric: bool?
                                       },
                                     ],
                                     ?alert_targets: Hash[("SNS"), {
                                         alert_target_arn: ::String,
                                         role_arn: ::String
                                       }],
                                     ?additional_metrics_to_retain: Array[::String],
                                     ?additional_metrics_to_retain_v2: Array[
                                       {
                                         metric: ::String,
                                         metric_dimension: {
                                           dimension_name: ::String,
                                           operator: ("IN" | "NOT_IN")?
                                         }?,
                                         export_metric: bool?
                                       },
                                     ],
                                     ?tags: Array[
                                       {
                                         key: ::String,
                                         value: ::String?
                                       },
                                     ],
                                     ?metrics_export_config: {
                                       mqtt_topic: ::String,
                                       role_arn: ::String
                                     }
                                   ) -> _CreateSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSecurityProfileResponseSuccess

      interface _CreateStreamResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateStreamResponse]
        def stream_id: () -> ::String
        def stream_arn: () -> ::String
        def description: () -> ::String
        def stream_version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_stream-instance_method
      def create_stream: (
                           stream_id: ::String,
                           ?description: ::String,
                           files: Array[
                             {
                               file_id: ::Integer?,
                               s3_location: {
                                 bucket: ::String?,
                                 key: ::String?,
                                 version: ::String?
                               }?
                             },
                           ],
                           role_arn: ::String,
                           ?tags: Array[
                             {
                               key: ::String,
                               value: ::String?
                             },
                           ]
                         ) -> _CreateStreamResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateStreamResponseSuccess

      interface _CreateThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateThingResponse]
        def thing_name: () -> ::String
        def thing_arn: () -> ::String
        def thing_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_thing-instance_method
      def create_thing: (
                          thing_name: ::String,
                          ?thing_type_name: ::String,
                          ?attribute_payload: {
                            attributes: Hash[::String, ::String]?,
                            merge: bool?
                          },
                          ?billing_group_name: ::String
                        ) -> _CreateThingResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateThingResponseSuccess

      interface _CreateThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateThingGroupResponse]
        def thing_group_name: () -> ::String
        def thing_group_arn: () -> ::String
        def thing_group_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_thing_group-instance_method
      def create_thing_group: (
                                thing_group_name: ::String,
                                ?parent_group_name: ::String,
                                ?thing_group_properties: {
                                  thing_group_description: ::String?,
                                  attribute_payload: {
                                    attributes: Hash[::String, ::String]?,
                                    merge: bool?
                                  }?
                                },
                                ?tags: Array[
                                  {
                                    key: ::String,
                                    value: ::String?
                                  },
                                ]
                              ) -> _CreateThingGroupResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateThingGroupResponseSuccess

      interface _CreateThingTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateThingTypeResponse]
        def thing_type_name: () -> ::String
        def thing_type_arn: () -> ::String
        def thing_type_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_thing_type-instance_method
      def create_thing_type: (
                               thing_type_name: ::String,
                               ?thing_type_properties: {
                                 thing_type_description: ::String?,
                                 searchable_attributes: Array[::String]?,
                                 mqtt5_configuration: {
                                   propagating_attributes: Array[
                                     {
                                       user_property_key: ::String?,
                                       thing_attribute: ::String?,
                                       connection_attribute: ::String?
                                     },
                                   ]?
                                 }?
                               },
                               ?tags: Array[
                                 {
                                   key: ::String,
                                   value: ::String?
                                 },
                               ]
                             ) -> _CreateThingTypeResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateThingTypeResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_topic_rule-instance_method
      def create_topic_rule: (
                               rule_name: ::String,
                               topic_rule_payload: {
                                 sql: ::String,
                                 description: ::String?,
                                 actions: Array[
                                   {
                                     dynamo_db: {
                                       table_name: ::String,
                                       role_arn: ::String,
                                       operation: ::String?,
                                       hash_key_field: ::String,
                                       hash_key_value: ::String,
                                       hash_key_type: ("STRING" | "NUMBER")?,
                                       range_key_field: ::String?,
                                       range_key_value: ::String?,
                                       range_key_type: ("STRING" | "NUMBER")?,
                                       payload_field: ::String?
                                     }?,
                                     dynamo_d_bv_2: {
                                       role_arn: ::String,
                                       put_item: {
                                         table_name: ::String
                                       }
                                     }?,
                                     lambda: {
                                       function_arn: ::String
                                     }?,
                                     sns: {
                                       target_arn: ::String,
                                       role_arn: ::String,
                                       message_format: ("RAW" | "JSON")?
                                     }?,
                                     sqs: {
                                       role_arn: ::String,
                                       queue_url: ::String,
                                       use_base_64: bool?
                                     }?,
                                     kinesis: {
                                       role_arn: ::String,
                                       stream_name: ::String,
                                       partition_key: ::String?
                                     }?,
                                     republish: {
                                       role_arn: ::String,
                                       topic: ::String,
                                       qos: ::Integer?,
                                       headers: {
                                         payload_format_indicator: ::String?,
                                         content_type: ::String?,
                                         response_topic: ::String?,
                                         correlation_data: ::String?,
                                         message_expiry: ::String?,
                                         user_properties: Array[
                                           {
                                             key: ::String,
                                             value: ::String
                                           },
                                         ]?
                                       }?
                                     }?,
                                     s3: {
                                       role_arn: ::String,
                                       bucket_name: ::String,
                                       key: ::String,
                                       canned_acl: ("private" | "public-read" | "public-read-write" | "aws-exec-read" | "authenticated-read" | "bucket-owner-read" | "bucket-owner-full-control" | "log-delivery-write")?
                                     }?,
                                     firehose: {
                                       role_arn: ::String,
                                       delivery_stream_name: ::String,
                                       separator: ::String?,
                                       batch_mode: bool?
                                     }?,
                                     cloudwatch_metric: {
                                       role_arn: ::String,
                                       metric_namespace: ::String,
                                       metric_name: ::String,
                                       metric_value: ::String,
                                       metric_unit: ::String,
                                       metric_timestamp: ::String?
                                     }?,
                                     cloudwatch_alarm: {
                                       role_arn: ::String,
                                       alarm_name: ::String,
                                       state_reason: ::String,
                                       state_value: ::String
                                     }?,
                                     cloudwatch_logs: {
                                       role_arn: ::String,
                                       log_group_name: ::String,
                                       batch_mode: bool?
                                     }?,
                                     elasticsearch: {
                                       role_arn: ::String,
                                       endpoint: ::String,
                                       index: ::String,
                                       type: ::String,
                                       id: ::String
                                     }?,
                                     salesforce: {
                                       token: ::String,
                                       url: ::String
                                     }?,
                                     iot_analytics: {
                                       channel_arn: ::String?,
                                       channel_name: ::String?,
                                       batch_mode: bool?,
                                       role_arn: ::String?
                                     }?,
                                     iot_events: {
                                       input_name: ::String,
                                       message_id: ::String?,
                                       batch_mode: bool?,
                                       role_arn: ::String
                                     }?,
                                     iot_site_wise: {
                                       put_asset_property_value_entries: Array[
                                         {
                                           entry_id: ::String?,
                                           asset_id: ::String?,
                                           property_id: ::String?,
                                           property_alias: ::String?,
                                           property_values: Array[
                                             {
                                               value: {
                                                 string_value: ::String?,
                                                 integer_value: ::String?,
                                                 double_value: ::String?,
                                                 boolean_value: ::String?
                                               },
                                               timestamp: {
                                                 time_in_seconds: ::String,
                                                 offset_in_nanos: ::String?
                                               },
                                               quality: ::String?
                                             },
                                           ]
                                         },
                                       ],
                                       role_arn: ::String
                                     }?,
                                     step_functions: {
                                       execution_name_prefix: ::String?,
                                       state_machine_name: ::String,
                                       role_arn: ::String
                                     }?,
                                     timestream: {
                                       role_arn: ::String,
                                       database_name: ::String,
                                       table_name: ::String,
                                       dimensions: Array[
                                         {
                                           name: ::String,
                                           value: ::String
                                         },
                                       ],
                                       timestamp: {
                                         value: ::String,
                                         unit: ::String
                                       }?
                                     }?,
                                     http: {
                                       url: ::String,
                                       confirmation_url: ::String?,
                                       headers: Array[
                                         {
                                           key: ::String,
                                           value: ::String
                                         },
                                       ]?,
                                       auth: {
                                         sigv4: {
                                           signing_region: ::String,
                                           service_name: ::String,
                                           role_arn: ::String
                                         }?
                                       }?
                                     }?,
                                     kafka: {
                                       destination_arn: ::String,
                                       topic: ::String,
                                       key: ::String?,
                                       partition: ::String?,
                                       client_properties: Hash[::String, ::String],
                                       headers: Array[
                                         {
                                           key: ::String,
                                           value: ::String
                                         },
                                       ]?
                                     }?,
                                     open_search: {
                                       role_arn: ::String,
                                       endpoint: ::String,
                                       index: ::String,
                                       type: ::String,
                                       id: ::String
                                     }?,
                                     location: {
                                       role_arn: ::String,
                                       tracker_name: ::String,
                                       device_id: ::String,
                                       timestamp: {
                                         value: ::String,
                                         unit: ::String?
                                       }?,
                                       latitude: ::String,
                                       longitude: ::String
                                     }?
                                   },
                                 ],
                                 rule_disabled: bool?,
                                 aws_iot_sql_version: ::String?,
                                 error_action: {
                                   dynamo_db: {
                                     table_name: ::String,
                                     role_arn: ::String,
                                     operation: ::String?,
                                     hash_key_field: ::String,
                                     hash_key_value: ::String,
                                     hash_key_type: ("STRING" | "NUMBER")?,
                                     range_key_field: ::String?,
                                     range_key_value: ::String?,
                                     range_key_type: ("STRING" | "NUMBER")?,
                                     payload_field: ::String?
                                   }?,
                                   dynamo_d_bv_2: {
                                     role_arn: ::String,
                                     put_item: {
                                       table_name: ::String
                                     }
                                   }?,
                                   lambda: {
                                     function_arn: ::String
                                   }?,
                                   sns: {
                                     target_arn: ::String,
                                     role_arn: ::String,
                                     message_format: ("RAW" | "JSON")?
                                   }?,
                                   sqs: {
                                     role_arn: ::String,
                                     queue_url: ::String,
                                     use_base_64: bool?
                                   }?,
                                   kinesis: {
                                     role_arn: ::String,
                                     stream_name: ::String,
                                     partition_key: ::String?
                                   }?,
                                   republish: {
                                     role_arn: ::String,
                                     topic: ::String,
                                     qos: ::Integer?,
                                     headers: {
                                       payload_format_indicator: ::String?,
                                       content_type: ::String?,
                                       response_topic: ::String?,
                                       correlation_data: ::String?,
                                       message_expiry: ::String?,
                                       user_properties: Array[
                                         {
                                           key: ::String,
                                           value: ::String
                                         },
                                       ]?
                                     }?
                                   }?,
                                   s3: {
                                     role_arn: ::String,
                                     bucket_name: ::String,
                                     key: ::String,
                                     canned_acl: ("private" | "public-read" | "public-read-write" | "aws-exec-read" | "authenticated-read" | "bucket-owner-read" | "bucket-owner-full-control" | "log-delivery-write")?
                                   }?,
                                   firehose: {
                                     role_arn: ::String,
                                     delivery_stream_name: ::String,
                                     separator: ::String?,
                                     batch_mode: bool?
                                   }?,
                                   cloudwatch_metric: {
                                     role_arn: ::String,
                                     metric_namespace: ::String,
                                     metric_name: ::String,
                                     metric_value: ::String,
                                     metric_unit: ::String,
                                     metric_timestamp: ::String?
                                   }?,
                                   cloudwatch_alarm: {
                                     role_arn: ::String,
                                     alarm_name: ::String,
                                     state_reason: ::String,
                                     state_value: ::String
                                   }?,
                                   cloudwatch_logs: {
                                     role_arn: ::String,
                                     log_group_name: ::String,
                                     batch_mode: bool?
                                   }?,
                                   elasticsearch: {
                                     role_arn: ::String,
                                     endpoint: ::String,
                                     index: ::String,
                                     type: ::String,
                                     id: ::String
                                   }?,
                                   salesforce: {
                                     token: ::String,
                                     url: ::String
                                   }?,
                                   iot_analytics: {
                                     channel_arn: ::String?,
                                     channel_name: ::String?,
                                     batch_mode: bool?,
                                     role_arn: ::String?
                                   }?,
                                   iot_events: {
                                     input_name: ::String,
                                     message_id: ::String?,
                                     batch_mode: bool?,
                                     role_arn: ::String
                                   }?,
                                   iot_site_wise: {
                                     put_asset_property_value_entries: Array[
                                       {
                                         entry_id: ::String?,
                                         asset_id: ::String?,
                                         property_id: ::String?,
                                         property_alias: ::String?,
                                         property_values: Array[
                                           {
                                             value: {
                                               string_value: ::String?,
                                               integer_value: ::String?,
                                               double_value: ::String?,
                                               boolean_value: ::String?
                                             },
                                             timestamp: {
                                               time_in_seconds: ::String,
                                               offset_in_nanos: ::String?
                                             },
                                             quality: ::String?
                                           },
                                         ]
                                       },
                                     ],
                                     role_arn: ::String
                                   }?,
                                   step_functions: {
                                     execution_name_prefix: ::String?,
                                     state_machine_name: ::String,
                                     role_arn: ::String
                                   }?,
                                   timestream: {
                                     role_arn: ::String,
                                     database_name: ::String,
                                     table_name: ::String,
                                     dimensions: Array[
                                       {
                                         name: ::String,
                                         value: ::String
                                       },
                                     ],
                                     timestamp: {
                                       value: ::String,
                                       unit: ::String
                                     }?
                                   }?,
                                   http: {
                                     url: ::String,
                                     confirmation_url: ::String?,
                                     headers: Array[
                                       {
                                         key: ::String,
                                         value: ::String
                                       },
                                     ]?,
                                     auth: {
                                       sigv4: {
                                         signing_region: ::String,
                                         service_name: ::String,
                                         role_arn: ::String
                                       }?
                                     }?
                                   }?,
                                   kafka: {
                                     destination_arn: ::String,
                                     topic: ::String,
                                     key: ::String?,
                                     partition: ::String?,
                                     client_properties: Hash[::String, ::String],
                                     headers: Array[
                                       {
                                         key: ::String,
                                         value: ::String
                                       },
                                     ]?
                                   }?,
                                   open_search: {
                                     role_arn: ::String,
                                     endpoint: ::String,
                                     index: ::String,
                                     type: ::String,
                                     id: ::String
                                   }?,
                                   location: {
                                     role_arn: ::String,
                                     tracker_name: ::String,
                                     device_id: ::String,
                                     timestamp: {
                                       value: ::String,
                                       unit: ::String?
                                     }?,
                                     latitude: ::String,
                                     longitude: ::String
                                   }?
                                 }?
                               },
                               ?tags: ::String
                             ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _CreateTopicRuleDestinationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTopicRuleDestinationResponse]
        def topic_rule_destination: () -> Types::TopicRuleDestination
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#create_topic_rule_destination-instance_method
      def create_topic_rule_destination: (
                                           destination_configuration: {
                                             http_url_configuration: {
                                               confirmation_url: ::String
                                             }?,
                                             vpc_configuration: {
                                               subnet_ids: Array[::String],
                                               security_groups: Array[::String]?,
                                               vpc_id: ::String,
                                               role_arn: ::String
                                             }?
                                           }
                                         ) -> _CreateTopicRuleDestinationResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTopicRuleDestinationResponseSuccess

      interface _DeleteAccountAuditConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteAccountAuditConfigurationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_account_audit_configuration-instance_method
      def delete_account_audit_configuration: (
                                                ?delete_scheduled_audits: bool
                                              ) -> _DeleteAccountAuditConfigurationResponseSuccess
                                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteAccountAuditConfigurationResponseSuccess

      interface _DeleteAuditSuppressionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteAuditSuppressionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_audit_suppression-instance_method
      def delete_audit_suppression: (
                                      check_name: ::String,
                                      resource_identifier: {
                                        device_certificate_id: ::String?,
                                        ca_certificate_id: ::String?,
                                        cognito_identity_pool_id: ::String?,
                                        client_id: ::String?,
                                        policy_version_identifier: {
                                          policy_name: ::String?,
                                          policy_version_id: ::String?
                                        }?,
                                        account: ::String?,
                                        iam_role_arn: ::String?,
                                        role_alias_arn: ::String?,
                                        issuer_certificate_identifier: {
                                          issuer_certificate_subject: ::String?,
                                          issuer_id: ::String?,
                                          issuer_certificate_serial_number: ::String?
                                        }?,
                                        device_certificate_arn: ::String?
                                      }
                                    ) -> _DeleteAuditSuppressionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteAuditSuppressionResponseSuccess

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

      interface _DeleteBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteBillingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_billing_group-instance_method
      def delete_billing_group: (
                                  billing_group_name: ::String,
                                  ?expected_version: ::Integer
                                ) -> _DeleteBillingGroupResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteBillingGroupResponseSuccess

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

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

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

      interface _DeleteCommandResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteCommandResponse]
        def status_code: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_command-instance_method
      def delete_command: (
                            command_id: ::String
                          ) -> _DeleteCommandResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteCommandResponseSuccess

      interface _DeleteCommandExecutionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteCommandExecutionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_command_execution-instance_method
      def delete_command_execution: (
                                      execution_id: ::String,
                                      target_arn: ::String
                                    ) -> _DeleteCommandExecutionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteCommandExecutionResponseSuccess

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

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

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

      interface _DeleteDynamicThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteDynamicThingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_dynamic_thing_group-instance_method
      def delete_dynamic_thing_group: (
                                        thing_group_name: ::String,
                                        ?expected_version: ::Integer
                                      ) -> _DeleteDynamicThingGroupResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteDynamicThingGroupResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_fleet_metric-instance_method
      def delete_fleet_metric: (
                                 metric_name: ::String,
                                 ?expected_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/IoT/Client.html#delete_job-instance_method
      def delete_job: (
                        job_id: ::String,
                        ?force: bool,
                        ?namespace_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/IoT/Client.html#delete_job_execution-instance_method
      def delete_job_execution: (
                                  job_id: ::String,
                                  thing_name: ::String,
                                  execution_number: ::Integer,
                                  ?force: bool,
                                  ?namespace_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/IoT/Client.html#delete_job_template-instance_method
      def delete_job_template: (
                                 job_template_id: ::String
                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

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

      interface _DeleteOTAUpdateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteOTAUpdateResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_ota_update-instance_method
      def delete_ota_update: (
                               ota_update_id: ::String,
                               ?delete_stream: bool,
                               ?force_delete_aws_job: bool
                             ) -> _DeleteOTAUpdateResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteOTAUpdateResponseSuccess

      interface _DeletePackageResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeletePackageResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_package-instance_method
      def delete_package: (
                            package_name: ::String,
                            ?client_token: ::String
                          ) -> _DeletePackageResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeletePackageResponseSuccess

      interface _DeletePackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeletePackageVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_package_version-instance_method
      def delete_package_version: (
                                    package_name: ::String,
                                    version_name: ::String,
                                    ?client_token: ::String
                                  ) -> _DeletePackageVersionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeletePackageVersionResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_policy-instance_method
      def delete_policy: (
                           policy_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/IoT/Client.html#delete_policy_version-instance_method
      def delete_policy_version: (
                                   policy_name: ::String,
                                   policy_version_id: ::String
                                 ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

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

      interface _DeleteProvisioningTemplateVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteProvisioningTemplateVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_provisioning_template_version-instance_method
      def delete_provisioning_template_version: (
                                                  template_name: ::String,
                                                  version_id: ::Integer
                                                ) -> _DeleteProvisioningTemplateVersionResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteProvisioningTemplateVersionResponseSuccess

      interface _DeleteRegistrationCodeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteRegistrationCodeResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_registration_code-instance_method
      def delete_registration_code: (
                                    ) -> _DeleteRegistrationCodeResponseSuccess
                                  | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteRegistrationCodeResponseSuccess

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

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

      interface _DeleteSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteSecurityProfileResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_security_profile-instance_method
      def delete_security_profile: (
                                     security_profile_name: ::String,
                                     ?expected_version: ::Integer
                                   ) -> _DeleteSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteSecurityProfileResponseSuccess

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

      interface _DeleteThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteThingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_thing-instance_method
      def delete_thing: (
                          thing_name: ::String,
                          ?expected_version: ::Integer
                        ) -> _DeleteThingResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteThingResponseSuccess

      interface _DeleteThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteThingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_thing_group-instance_method
      def delete_thing_group: (
                                thing_group_name: ::String,
                                ?expected_version: ::Integer
                              ) -> _DeleteThingGroupResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteThingGroupResponseSuccess

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

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

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

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#delete_v2_logging_level-instance_method
      def delete_v2_logging_level: (
                                     target_type: ("DEFAULT" | "THING_GROUP" | "CLIENT_ID" | "SOURCE_IP" | "PRINCIPAL_ID"),
                                     target_name: ::String
                                   ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeprecateThingTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeprecateThingTypeResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#deprecate_thing_type-instance_method
      def deprecate_thing_type: (
                                  thing_type_name: ::String,
                                  ?undo_deprecate: bool
                                ) -> _DeprecateThingTypeResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeprecateThingTypeResponseSuccess

      interface _DescribeAccountAuditConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAccountAuditConfigurationResponse]
        def role_arn: () -> ::String
        def audit_notification_target_configurations: () -> ::Hash[("SNS"), Types::AuditNotificationTarget]
        def audit_check_configurations: () -> ::Hash[::String, Types::AuditCheckConfiguration]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_account_audit_configuration-instance_method
      def describe_account_audit_configuration: (
                                                ) -> _DescribeAccountAuditConfigurationResponseSuccess
                                              | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAccountAuditConfigurationResponseSuccess

      interface _DescribeAuditFindingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuditFindingResponse]
        def finding: () -> Types::AuditFinding
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_audit_finding-instance_method
      def describe_audit_finding: (
                                    finding_id: ::String
                                  ) -> _DescribeAuditFindingResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuditFindingResponseSuccess

      interface _DescribeAuditMitigationActionsTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuditMitigationActionsTaskResponse]
        def task_status: () -> ("IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELED")
        def start_time: () -> ::Time
        def end_time: () -> ::Time
        def task_statistics: () -> ::Hash[::String, Types::TaskStatisticsForAuditCheck]
        def target: () -> Types::AuditMitigationActionsTaskTarget
        def audit_check_to_actions_mapping: () -> ::Hash[::String, ::Array[::String]]
        def actions_definition: () -> ::Array[Types::MitigationAction]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_audit_mitigation_actions_task-instance_method
      def describe_audit_mitigation_actions_task: (
                                                    task_id: ::String
                                                  ) -> _DescribeAuditMitigationActionsTaskResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuditMitigationActionsTaskResponseSuccess

      interface _DescribeAuditSuppressionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuditSuppressionResponse]
        def check_name: () -> ::String
        def resource_identifier: () -> Types::ResourceIdentifier
        def expiration_date: () -> ::Time
        def suppress_indefinitely: () -> bool
        def description: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_audit_suppression-instance_method
      def describe_audit_suppression: (
                                        check_name: ::String,
                                        resource_identifier: {
                                          device_certificate_id: ::String?,
                                          ca_certificate_id: ::String?,
                                          cognito_identity_pool_id: ::String?,
                                          client_id: ::String?,
                                          policy_version_identifier: {
                                            policy_name: ::String?,
                                            policy_version_id: ::String?
                                          }?,
                                          account: ::String?,
                                          iam_role_arn: ::String?,
                                          role_alias_arn: ::String?,
                                          issuer_certificate_identifier: {
                                            issuer_certificate_subject: ::String?,
                                            issuer_id: ::String?,
                                            issuer_certificate_serial_number: ::String?
                                          }?,
                                          device_certificate_arn: ::String?
                                        }
                                      ) -> _DescribeAuditSuppressionResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuditSuppressionResponseSuccess

      interface _DescribeAuditTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuditTaskResponse]
        def task_status: () -> ("IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELED")
        def task_type: () -> ("ON_DEMAND_AUDIT_TASK" | "SCHEDULED_AUDIT_TASK")
        def task_start_time: () -> ::Time
        def task_statistics: () -> Types::TaskStatistics
        def scheduled_audit_name: () -> ::String
        def audit_details: () -> ::Hash[::String, Types::AuditCheckDetails]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_audit_task-instance_method
      def describe_audit_task: (
                                 task_id: ::String
                               ) -> _DescribeAuditTaskResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuditTaskResponseSuccess

      interface _DescribeAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAuthorizerResponse]
        def authorizer_description: () -> Types::AuthorizerDescription
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_authorizer-instance_method
      def describe_authorizer: (
                                 authorizer_name: ::String
                               ) -> _DescribeAuthorizerResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAuthorizerResponseSuccess

      interface _DescribeBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeBillingGroupResponse]
        def billing_group_name: () -> ::String
        def billing_group_id: () -> ::String
        def billing_group_arn: () -> ::String
        def version: () -> ::Integer
        def billing_group_properties: () -> Types::BillingGroupProperties
        def billing_group_metadata: () -> Types::BillingGroupMetadata
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_billing_group-instance_method
      def describe_billing_group: (
                                    billing_group_name: ::String
                                  ) -> _DescribeBillingGroupResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeBillingGroupResponseSuccess

      interface _DescribeCACertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeCACertificateResponse]
        def certificate_description: () -> Types::CACertificateDescription
        def registration_config: () -> Types::RegistrationConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_ca_certificate-instance_method
      def describe_ca_certificate: (
                                     certificate_id: ::String
                                   ) -> _DescribeCACertificateResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCACertificateResponseSuccess

      interface _DescribeCertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeCertificateResponse]
        def certificate_description: () -> Types::CertificateDescription
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_certificate-instance_method
      def describe_certificate: (
                                  certificate_id: ::String
                                ) -> _DescribeCertificateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCertificateResponseSuccess

      interface _DescribeCertificateProviderResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeCertificateProviderResponse]
        def certificate_provider_name: () -> ::String
        def certificate_provider_arn: () -> ::String
        def lambda_function_arn: () -> ::String
        def account_default_for_operations: () -> ::Array[("CreateCertificateFromCsr")]
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_certificate_provider-instance_method
      def describe_certificate_provider: (
                                           certificate_provider_name: ::String
                                         ) -> _DescribeCertificateProviderResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCertificateProviderResponseSuccess

      interface _DescribeCustomMetricResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeCustomMetricResponse]
        def metric_name: () -> ::String
        def metric_arn: () -> ::String
        def metric_type: () -> ("string-list" | "ip-address-list" | "number-list" | "number")
        def display_name: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_custom_metric-instance_method
      def describe_custom_metric: (
                                    metric_name: ::String
                                  ) -> _DescribeCustomMetricResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCustomMetricResponseSuccess

      interface _DescribeDefaultAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDefaultAuthorizerResponse]
        def authorizer_description: () -> Types::AuthorizerDescription
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_default_authorizer-instance_method
      def describe_default_authorizer: (
                                       ) -> _DescribeDefaultAuthorizerResponseSuccess
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDefaultAuthorizerResponseSuccess

      interface _DescribeDetectMitigationActionsTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDetectMitigationActionsTaskResponse]
        def task_summary: () -> Types::DetectMitigationActionsTaskSummary
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_detect_mitigation_actions_task-instance_method
      def describe_detect_mitigation_actions_task: (
                                                     task_id: ::String
                                                   ) -> _DescribeDetectMitigationActionsTaskResponseSuccess
                                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDetectMitigationActionsTaskResponseSuccess

      interface _DescribeDimensionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDimensionResponse]
        def name: () -> ::String
        def arn: () -> ::String
        def type: () -> ("TOPIC_FILTER")
        def string_values: () -> ::Array[::String]
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_dimension-instance_method
      def describe_dimension: (
                                name: ::String
                              ) -> _DescribeDimensionResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDimensionResponseSuccess

      interface _DescribeDomainConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDomainConfigurationResponse]
        def domain_configuration_name: () -> ::String
        def domain_configuration_arn: () -> ::String
        def domain_name: () -> ::String
        def server_certificates: () -> ::Array[Types::ServerCertificateSummary]
        def authorizer_config: () -> Types::AuthorizerConfig
        def domain_configuration_status: () -> ("ENABLED" | "DISABLED")
        def service_type: () -> ("DATA" | "CREDENTIAL_PROVIDER" | "JOBS")
        def domain_type: () -> ("ENDPOINT" | "AWS_MANAGED" | "CUSTOMER_MANAGED")
        def last_status_change_date: () -> ::Time
        def tls_config: () -> Types::TlsConfig
        def server_certificate_config: () -> Types::ServerCertificateConfig
        def authentication_type: () -> ("CUSTOM_AUTH_X509" | "CUSTOM_AUTH" | "AWS_X509" | "AWS_SIGV4" | "DEFAULT")
        def application_protocol: () -> ("SECURE_MQTT" | "MQTT_WSS" | "HTTPS" | "DEFAULT")
        def client_certificate_config: () -> Types::ClientCertificateConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_domain_configuration-instance_method
      def describe_domain_configuration: (
                                           domain_configuration_name: ::String
                                         ) -> _DescribeDomainConfigurationResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDomainConfigurationResponseSuccess

      interface _DescribeEndpointResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEndpointResponse]
        def endpoint_address: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_endpoint-instance_method
      def describe_endpoint: (
                               ?endpoint_type: ::String
                             ) -> _DescribeEndpointResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEndpointResponseSuccess

      interface _DescribeEventConfigurationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEventConfigurationsResponse]
        def event_configurations: () -> ::Hash[("THING" | "THING_GROUP" | "THING_TYPE" | "THING_GROUP_MEMBERSHIP" | "THING_GROUP_HIERARCHY" | "THING_TYPE_ASSOCIATION" | "JOB" | "JOB_EXECUTION" | "POLICY" | "CERTIFICATE" | "CA_CERTIFICATE"), Types::Configuration]
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_event_configurations-instance_method
      def describe_event_configurations: (
                                         ) -> _DescribeEventConfigurationsResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEventConfigurationsResponseSuccess

      interface _DescribeFleetMetricResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeFleetMetricResponse]
        def metric_name: () -> ::String
        def query_string: () -> ::String
        def aggregation_type: () -> Types::AggregationType
        def period: () -> ::Integer
        def aggregation_field: () -> ::String
        def description: () -> ::String
        def query_version: () -> ::String
        def index_name: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def unit: () -> ("Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second" | "None")
        def version: () -> ::Integer
        def metric_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_fleet_metric-instance_method
      def describe_fleet_metric: (
                                   metric_name: ::String
                                 ) -> _DescribeFleetMetricResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeFleetMetricResponseSuccess

      interface _DescribeIndexResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeIndexResponse]
        def index_name: () -> ::String
        def index_status: () -> ("ACTIVE" | "BUILDING" | "REBUILDING")
        def schema: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_index-instance_method
      def describe_index: (
                            index_name: ::String
                          ) -> _DescribeIndexResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeIndexResponseSuccess

      interface _DescribeJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeJobResponse]
        def document_source: () -> ::String
        def job: () -> Types::Job
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_job-instance_method
      def describe_job: (
                          job_id: ::String,
                          ?before_substitution: bool
                        ) -> _DescribeJobResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeJobResponseSuccess

      interface _DescribeJobExecutionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeJobExecutionResponse]
        def execution: () -> Types::JobExecution
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_job_execution-instance_method
      def describe_job_execution: (
                                    job_id: ::String,
                                    thing_name: ::String,
                                    ?execution_number: ::Integer
                                  ) -> _DescribeJobExecutionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeJobExecutionResponseSuccess

      interface _DescribeJobTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeJobTemplateResponse]
        def job_template_arn: () -> ::String
        def job_template_id: () -> ::String
        def description: () -> ::String
        def document_source: () -> ::String
        def document: () -> ::String
        def created_at: () -> ::Time
        def presigned_url_config: () -> Types::PresignedUrlConfig
        def job_executions_rollout_config: () -> Types::JobExecutionsRolloutConfig
        def abort_config: () -> Types::AbortConfig
        def timeout_config: () -> Types::TimeoutConfig
        def job_executions_retry_config: () -> Types::JobExecutionsRetryConfig
        def maintenance_windows: () -> ::Array[Types::MaintenanceWindow]
        def destination_package_versions: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_job_template-instance_method
      def describe_job_template: (
                                   job_template_id: ::String
                                 ) -> _DescribeJobTemplateResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeJobTemplateResponseSuccess

      interface _DescribeManagedJobTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeManagedJobTemplateResponse]
        def template_name: () -> ::String
        def template_arn: () -> ::String
        def description: () -> ::String
        def template_version: () -> ::String
        def environments: () -> ::Array[::String]
        def document_parameters: () -> ::Array[Types::DocumentParameter]
        def document: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_managed_job_template-instance_method
      def describe_managed_job_template: (
                                           template_name: ::String,
                                           ?template_version: ::String
                                         ) -> _DescribeManagedJobTemplateResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeManagedJobTemplateResponseSuccess

      interface _DescribeMitigationActionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeMitigationActionResponse]
        def action_name: () -> ::String
        def action_type: () -> ("UPDATE_DEVICE_CERTIFICATE" | "UPDATE_CA_CERTIFICATE" | "ADD_THINGS_TO_THING_GROUP" | "REPLACE_DEFAULT_POLICY_VERSION" | "ENABLE_IOT_LOGGING" | "PUBLISH_FINDING_TO_SNS")
        def action_arn: () -> ::String
        def action_id: () -> ::String
        def role_arn: () -> ::String
        def action_params: () -> Types::MitigationActionParams
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_mitigation_action-instance_method
      def describe_mitigation_action: (
                                        action_name: ::String
                                      ) -> _DescribeMitigationActionResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeMitigationActionResponseSuccess

      interface _DescribeProvisioningTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeProvisioningTemplateResponse]
        def template_arn: () -> ::String
        def template_name: () -> ::String
        def description: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def default_version_id: () -> ::Integer
        def template_body: () -> ::String
        def enabled: () -> bool
        def provisioning_role_arn: () -> ::String
        def pre_provisioning_hook: () -> Types::ProvisioningHook
        def type: () -> ("FLEET_PROVISIONING" | "JITP")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_provisioning_template-instance_method
      def describe_provisioning_template: (
                                            template_name: ::String
                                          ) -> _DescribeProvisioningTemplateResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeProvisioningTemplateResponseSuccess

      interface _DescribeProvisioningTemplateVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeProvisioningTemplateVersionResponse]
        def version_id: () -> ::Integer
        def creation_date: () -> ::Time
        def template_body: () -> ::String
        def is_default_version: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_provisioning_template_version-instance_method
      def describe_provisioning_template_version: (
                                                    template_name: ::String,
                                                    version_id: ::Integer
                                                  ) -> _DescribeProvisioningTemplateVersionResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeProvisioningTemplateVersionResponseSuccess

      interface _DescribeRoleAliasResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeRoleAliasResponse]
        def role_alias_description: () -> Types::RoleAliasDescription
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_role_alias-instance_method
      def describe_role_alias: (
                                 role_alias: ::String
                               ) -> _DescribeRoleAliasResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeRoleAliasResponseSuccess

      interface _DescribeScheduledAuditResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeScheduledAuditResponse]
        def frequency: () -> ("DAILY" | "WEEKLY" | "BIWEEKLY" | "MONTHLY")
        def day_of_month: () -> ::String
        def day_of_week: () -> ("SUN" | "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT")
        def target_check_names: () -> ::Array[::String]
        def scheduled_audit_name: () -> ::String
        def scheduled_audit_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_scheduled_audit-instance_method
      def describe_scheduled_audit: (
                                      scheduled_audit_name: ::String
                                    ) -> _DescribeScheduledAuditResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeScheduledAuditResponseSuccess

      interface _DescribeSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeSecurityProfileResponse]
        def security_profile_name: () -> ::String
        def security_profile_arn: () -> ::String
        def security_profile_description: () -> ::String
        def behaviors: () -> ::Array[Types::Behavior]
        def alert_targets: () -> ::Hash[("SNS"), Types::AlertTarget]
        def additional_metrics_to_retain: () -> ::Array[::String]
        def additional_metrics_to_retain_v2: () -> ::Array[Types::MetricToRetain]
        def version: () -> ::Integer
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def metrics_export_config: () -> Types::MetricsExportConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_security_profile-instance_method
      def describe_security_profile: (
                                       security_profile_name: ::String
                                     ) -> _DescribeSecurityProfileResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeSecurityProfileResponseSuccess

      interface _DescribeStreamResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeStreamResponse]
        def stream_info: () -> Types::StreamInfo
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_stream-instance_method
      def describe_stream: (
                             stream_id: ::String
                           ) -> _DescribeStreamResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeStreamResponseSuccess

      interface _DescribeThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeThingResponse]
        def default_client_id: () -> ::String
        def thing_name: () -> ::String
        def thing_id: () -> ::String
        def thing_arn: () -> ::String
        def thing_type_name: () -> ::String
        def attributes: () -> ::Hash[::String, ::String]
        def version: () -> ::Integer
        def billing_group_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_thing-instance_method
      def describe_thing: (
                            thing_name: ::String
                          ) -> _DescribeThingResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeThingResponseSuccess

      interface _DescribeThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeThingGroupResponse]
        def thing_group_name: () -> ::String
        def thing_group_id: () -> ::String
        def thing_group_arn: () -> ::String
        def version: () -> ::Integer
        def thing_group_properties: () -> Types::ThingGroupProperties
        def thing_group_metadata: () -> Types::ThingGroupMetadata
        def index_name: () -> ::String
        def query_string: () -> ::String
        def query_version: () -> ::String
        def status: () -> ("ACTIVE" | "BUILDING" | "REBUILDING")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_thing_group-instance_method
      def describe_thing_group: (
                                  thing_group_name: ::String
                                ) -> _DescribeThingGroupResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeThingGroupResponseSuccess

      interface _DescribeThingRegistrationTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeThingRegistrationTaskResponse]
        def task_id: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def template_body: () -> ::String
        def input_file_bucket: () -> ::String
        def input_file_key: () -> ::String
        def role_arn: () -> ::String
        def status: () -> ("InProgress" | "Completed" | "Failed" | "Cancelled" | "Cancelling")
        def message: () -> ::String
        def success_count: () -> ::Integer
        def failure_count: () -> ::Integer
        def percentage_progress: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_thing_registration_task-instance_method
      def describe_thing_registration_task: (
                                              task_id: ::String
                                            ) -> _DescribeThingRegistrationTaskResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeThingRegistrationTaskResponseSuccess

      interface _DescribeThingTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeThingTypeResponse]
        def thing_type_name: () -> ::String
        def thing_type_id: () -> ::String
        def thing_type_arn: () -> ::String
        def thing_type_properties: () -> Types::ThingTypeProperties
        def thing_type_metadata: () -> Types::ThingTypeMetadata
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#describe_thing_type-instance_method
      def describe_thing_type: (
                                 thing_type_name: ::String
                               ) -> _DescribeThingTypeResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeThingTypeResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#detach_policy-instance_method
      def detach_policy: (
                           policy_name: ::String,
                           target: ::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/IoT/Client.html#detach_principal_policy-instance_method
      def detach_principal_policy: (
                                     policy_name: ::String,
                                     principal: ::String
                                   ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DetachSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DetachSecurityProfileResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#detach_security_profile-instance_method
      def detach_security_profile: (
                                     security_profile_name: ::String,
                                     security_profile_target_arn: ::String
                                   ) -> _DetachSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DetachSecurityProfileResponseSuccess

      interface _DetachThingPrincipalResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DetachThingPrincipalResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#detach_thing_principal-instance_method
      def detach_thing_principal: (
                                    thing_name: ::String,
                                    principal: ::String
                                  ) -> _DetachThingPrincipalResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DetachThingPrincipalResponseSuccess

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

      interface _DisassociateSbomFromPackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DisassociateSbomFromPackageVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#disassociate_sbom_from_package_version-instance_method
      def disassociate_sbom_from_package_version: (
                                                    package_name: ::String,
                                                    version_name: ::String,
                                                    ?client_token: ::String
                                                  ) -> _DisassociateSbomFromPackageVersionResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DisassociateSbomFromPackageVersionResponseSuccess

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

      interface _GetBehaviorModelTrainingSummariesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetBehaviorModelTrainingSummariesResponse]
        def summaries: () -> ::Array[Types::BehaviorModelTrainingSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_behavior_model_training_summaries-instance_method
      def get_behavior_model_training_summaries: (
                                                   ?security_profile_name: ::String,
                                                   ?max_results: ::Integer,
                                                   ?next_token: ::String
                                                 ) -> _GetBehaviorModelTrainingSummariesResponseSuccess
                                               | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBehaviorModelTrainingSummariesResponseSuccess

      interface _GetBucketsAggregationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetBucketsAggregationResponse]
        def total_count: () -> ::Integer
        def buckets: () -> ::Array[Types::Bucket]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_buckets_aggregation-instance_method
      def get_buckets_aggregation: (
                                     ?index_name: ::String,
                                     query_string: ::String,
                                     aggregation_field: ::String,
                                     ?query_version: ::String,
                                     buckets_aggregation_type: {
                                       terms_aggregation: {
                                         max_buckets: ::Integer?
                                       }?
                                     }
                                   ) -> _GetBucketsAggregationResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBucketsAggregationResponseSuccess

      interface _GetCardinalityResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCardinalityResponse]
        def cardinality: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_cardinality-instance_method
      def get_cardinality: (
                             ?index_name: ::String,
                             query_string: ::String,
                             ?aggregation_field: ::String,
                             ?query_version: ::String
                           ) -> _GetCardinalityResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCardinalityResponseSuccess

      interface _GetCommandResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCommandResponse]
        def command_id: () -> ::String
        def command_arn: () -> ::String
        def namespace: () -> ("AWS-IoT" | "AWS-IoT-FleetWise")
        def display_name: () -> ::String
        def description: () -> ::String
        def mandatory_parameters: () -> ::Array[Types::CommandParameter]
        def payload: () -> Types::CommandPayload
        def role_arn: () -> ::String
        def created_at: () -> ::Time
        def last_updated_at: () -> ::Time
        def deprecated: () -> bool
        def pending_deletion: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_command-instance_method
      def get_command: (
                         command_id: ::String
                       ) -> _GetCommandResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCommandResponseSuccess

      interface _GetCommandExecutionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCommandExecutionResponse]
        def execution_id: () -> ::String
        def command_arn: () -> ::String
        def target_arn: () -> ::String
        def status: () -> ("CREATED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "REJECTED" | "TIMED_OUT")
        def status_reason: () -> Types::StatusReason
        def result: () -> ::Hash[::String, Types::CommandExecutionResult]
        def parameters: () -> ::Hash[::String, Types::CommandParameterValue]
        def execution_timeout_seconds: () -> ::Integer
        def created_at: () -> ::Time
        def last_updated_at: () -> ::Time
        def started_at: () -> ::Time
        def completed_at: () -> ::Time
        def time_to_live: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_command_execution-instance_method
      def get_command_execution: (
                                   execution_id: ::String,
                                   target_arn: ::String,
                                   ?include_result: bool
                                 ) -> _GetCommandExecutionResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCommandExecutionResponseSuccess

      interface _GetEffectivePoliciesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetEffectivePoliciesResponse]
        def effective_policies: () -> ::Array[Types::EffectivePolicy]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_effective_policies-instance_method
      def get_effective_policies: (
                                    ?principal: ::String,
                                    ?cognito_identity_pool_id: ::String,
                                    ?thing_name: ::String
                                  ) -> _GetEffectivePoliciesResponseSuccess
                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEffectivePoliciesResponseSuccess

      interface _GetIndexingConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetIndexingConfigurationResponse]
        def thing_indexing_configuration: () -> Types::ThingIndexingConfiguration
        def thing_group_indexing_configuration: () -> Types::ThingGroupIndexingConfiguration
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_indexing_configuration-instance_method
      def get_indexing_configuration: (
                                      ) -> _GetIndexingConfigurationResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetIndexingConfigurationResponseSuccess

      interface _GetJobDocumentResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetJobDocumentResponse]
        def document: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_job_document-instance_method
      def get_job_document: (
                              job_id: ::String,
                              ?before_substitution: bool
                            ) -> _GetJobDocumentResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetJobDocumentResponseSuccess

      interface _GetLoggingOptionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetLoggingOptionsResponse]
        def role_arn: () -> ::String
        def log_level: () -> ("DEBUG" | "INFO" | "ERROR" | "WARN" | "DISABLED")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_logging_options-instance_method
      def get_logging_options: (
                               ) -> _GetLoggingOptionsResponseSuccess
                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetLoggingOptionsResponseSuccess

      interface _GetOTAUpdateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetOTAUpdateResponse]
        def ota_update_info: () -> Types::OTAUpdateInfo
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_ota_update-instance_method
      def get_ota_update: (
                            ota_update_id: ::String
                          ) -> _GetOTAUpdateResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetOTAUpdateResponseSuccess

      interface _GetPackageResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPackageResponse]
        def package_name: () -> ::String
        def package_arn: () -> ::String
        def description: () -> ::String
        def default_version_name: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_package-instance_method
      def get_package: (
                         package_name: ::String
                       ) -> _GetPackageResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPackageResponseSuccess

      interface _GetPackageConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPackageConfigurationResponse]
        def version_update_by_jobs_config: () -> Types::VersionUpdateByJobsConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_package_configuration-instance_method
      def get_package_configuration: (
                                     ) -> _GetPackageConfigurationResponseSuccess
                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPackageConfigurationResponseSuccess

      interface _GetPackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPackageVersionResponse]
        def package_version_arn: () -> ::String
        def package_name: () -> ::String
        def version_name: () -> ::String
        def description: () -> ::String
        def attributes: () -> ::Hash[::String, ::String]
        def artifact: () -> Types::PackageVersionArtifact
        def status: () -> ("DRAFT" | "PUBLISHED" | "DEPRECATED")
        def error_reason: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def sbom: () -> Types::Sbom
        def sbom_validation_status: () -> ("IN_PROGRESS" | "FAILED" | "SUCCEEDED")
        def recipe: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_package_version-instance_method
      def get_package_version: (
                                 package_name: ::String,
                                 version_name: ::String
                               ) -> _GetPackageVersionResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPackageVersionResponseSuccess

      interface _GetPercentilesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPercentilesResponse]
        def percentiles: () -> ::Array[Types::PercentPair]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_percentiles-instance_method
      def get_percentiles: (
                             ?index_name: ::String,
                             query_string: ::String,
                             ?aggregation_field: ::String,
                             ?query_version: ::String,
                             ?percents: Array[::Float]
                           ) -> _GetPercentilesResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPercentilesResponseSuccess

      interface _GetPolicyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPolicyResponse]
        def policy_name: () -> ::String
        def policy_arn: () -> ::String
        def policy_document: () -> ::String
        def default_version_id: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def generation_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_policy-instance_method
      def get_policy: (
                        policy_name: ::String
                      ) -> _GetPolicyResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPolicyResponseSuccess

      interface _GetPolicyVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPolicyVersionResponse]
        def policy_arn: () -> ::String
        def policy_name: () -> ::String
        def policy_document: () -> ::String
        def policy_version_id: () -> ::String
        def is_default_version: () -> bool
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def generation_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_policy_version-instance_method
      def get_policy_version: (
                                policy_name: ::String,
                                policy_version_id: ::String
                              ) -> _GetPolicyVersionResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPolicyVersionResponseSuccess

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

      interface _GetStatisticsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetStatisticsResponse]
        def statistics: () -> Types::Statistics
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_statistics-instance_method
      def get_statistics: (
                            ?index_name: ::String,
                            query_string: ::String,
                            ?aggregation_field: ::String,
                            ?query_version: ::String
                          ) -> _GetStatisticsResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetStatisticsResponseSuccess

      interface _GetTopicRuleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTopicRuleResponse]
        def rule_arn: () -> ::String
        def rule: () -> Types::TopicRule
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_topic_rule-instance_method
      def get_topic_rule: (
                            rule_name: ::String
                          ) -> _GetTopicRuleResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTopicRuleResponseSuccess

      interface _GetTopicRuleDestinationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTopicRuleDestinationResponse]
        def topic_rule_destination: () -> Types::TopicRuleDestination
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_topic_rule_destination-instance_method
      def get_topic_rule_destination: (
                                        arn: ::String
                                      ) -> _GetTopicRuleDestinationResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTopicRuleDestinationResponseSuccess

      interface _GetV2LoggingOptionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetV2LoggingOptionsResponse]
        def role_arn: () -> ::String
        def default_log_level: () -> ("DEBUG" | "INFO" | "ERROR" | "WARN" | "DISABLED")
        def disable_all_logs: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#get_v2_logging_options-instance_method
      def get_v2_logging_options: (
                                  ) -> _GetV2LoggingOptionsResponseSuccess
                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetV2LoggingOptionsResponseSuccess

      interface _ListActiveViolationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListActiveViolationsResponse]
        def active_violations: () -> ::Array[Types::ActiveViolation]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_active_violations-instance_method
      def list_active_violations: (
                                    ?thing_name: ::String,
                                    ?security_profile_name: ::String,
                                    ?behavior_criteria_type: ("STATIC" | "STATISTICAL" | "MACHINE_LEARNING"),
                                    ?list_suppressed_alerts: bool,
                                    ?verification_state: ("FALSE_POSITIVE" | "BENIGN_POSITIVE" | "TRUE_POSITIVE" | "UNKNOWN"),
                                    ?next_token: ::String,
                                    ?max_results: ::Integer
                                  ) -> _ListActiveViolationsResponseSuccess
                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListActiveViolationsResponseSuccess

      interface _ListAttachedPoliciesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAttachedPoliciesResponse]
        def policies: () -> ::Array[Types::Policy]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_attached_policies-instance_method
      def list_attached_policies: (
                                    target: ::String,
                                    ?recursive: bool,
                                    ?marker: ::String,
                                    ?page_size: ::Integer
                                  ) -> _ListAttachedPoliciesResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAttachedPoliciesResponseSuccess

      interface _ListAuditFindingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuditFindingsResponse]
        def findings: () -> ::Array[Types::AuditFinding]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_audit_findings-instance_method
      def list_audit_findings: (
                                 ?task_id: ::String,
                                 ?check_name: ::String,
                                 ?resource_identifier: {
                                   device_certificate_id: ::String?,
                                   ca_certificate_id: ::String?,
                                   cognito_identity_pool_id: ::String?,
                                   client_id: ::String?,
                                   policy_version_identifier: {
                                     policy_name: ::String?,
                                     policy_version_id: ::String?
                                   }?,
                                   account: ::String?,
                                   iam_role_arn: ::String?,
                                   role_alias_arn: ::String?,
                                   issuer_certificate_identifier: {
                                     issuer_certificate_subject: ::String?,
                                     issuer_id: ::String?,
                                     issuer_certificate_serial_number: ::String?
                                   }?,
                                   device_certificate_arn: ::String?
                                 },
                                 ?max_results: ::Integer,
                                 ?next_token: ::String,
                                 ?start_time: ::Time,
                                 ?end_time: ::Time,
                                 ?list_suppressed_findings: bool
                               ) -> _ListAuditFindingsResponseSuccess
                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuditFindingsResponseSuccess

      interface _ListAuditMitigationActionsExecutionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuditMitigationActionsExecutionsResponse]
        def actions_executions: () -> ::Array[Types::AuditMitigationActionExecutionMetadata]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_audit_mitigation_actions_executions-instance_method
      def list_audit_mitigation_actions_executions: (
                                                      task_id: ::String,
                                                      ?action_status: ("IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELED" | "SKIPPED" | "PENDING"),
                                                      finding_id: ::String,
                                                      ?max_results: ::Integer,
                                                      ?next_token: ::String
                                                    ) -> _ListAuditMitigationActionsExecutionsResponseSuccess
                                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuditMitigationActionsExecutionsResponseSuccess

      interface _ListAuditMitigationActionsTasksResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuditMitigationActionsTasksResponse]
        def tasks: () -> ::Array[Types::AuditMitigationActionsTaskMetadata]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_audit_mitigation_actions_tasks-instance_method
      def list_audit_mitigation_actions_tasks: (
                                                 ?audit_task_id: ::String,
                                                 ?finding_id: ::String,
                                                 ?task_status: ("IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELED"),
                                                 ?max_results: ::Integer,
                                                 ?next_token: ::String,
                                                 start_time: ::Time,
                                                 end_time: ::Time
                                               ) -> _ListAuditMitigationActionsTasksResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuditMitigationActionsTasksResponseSuccess

      interface _ListAuditSuppressionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuditSuppressionsResponse]
        def suppressions: () -> ::Array[Types::AuditSuppression]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_audit_suppressions-instance_method
      def list_audit_suppressions: (
                                     ?check_name: ::String,
                                     ?resource_identifier: {
                                       device_certificate_id: ::String?,
                                       ca_certificate_id: ::String?,
                                       cognito_identity_pool_id: ::String?,
                                       client_id: ::String?,
                                       policy_version_identifier: {
                                         policy_name: ::String?,
                                         policy_version_id: ::String?
                                       }?,
                                       account: ::String?,
                                       iam_role_arn: ::String?,
                                       role_alias_arn: ::String?,
                                       issuer_certificate_identifier: {
                                         issuer_certificate_subject: ::String?,
                                         issuer_id: ::String?,
                                         issuer_certificate_serial_number: ::String?
                                       }?,
                                       device_certificate_arn: ::String?
                                     },
                                     ?ascending_order: bool,
                                     ?next_token: ::String,
                                     ?max_results: ::Integer
                                   ) -> _ListAuditSuppressionsResponseSuccess
                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuditSuppressionsResponseSuccess

      interface _ListAuditTasksResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuditTasksResponse]
        def tasks: () -> ::Array[Types::AuditTaskMetadata]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_audit_tasks-instance_method
      def list_audit_tasks: (
                              start_time: ::Time,
                              end_time: ::Time,
                              ?task_type: ("ON_DEMAND_AUDIT_TASK" | "SCHEDULED_AUDIT_TASK"),
                              ?task_status: ("IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELED"),
                              ?next_token: ::String,
                              ?max_results: ::Integer
                            ) -> _ListAuditTasksResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuditTasksResponseSuccess

      interface _ListAuthorizersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListAuthorizersResponse]
        def authorizers: () -> ::Array[Types::AuthorizerSummary]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_authorizers-instance_method
      def list_authorizers: (
                              ?page_size: ::Integer,
                              ?marker: ::String,
                              ?ascending_order: bool,
                              ?status: ("ACTIVE" | "INACTIVE")
                            ) -> _ListAuthorizersResponseSuccess
                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAuthorizersResponseSuccess

      interface _ListBillingGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListBillingGroupsResponse]
        def billing_groups: () -> ::Array[Types::GroupNameAndArn]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_billing_groups-instance_method
      def list_billing_groups: (
                                 ?next_token: ::String,
                                 ?max_results: ::Integer,
                                 ?name_prefix_filter: ::String
                               ) -> _ListBillingGroupsResponseSuccess
                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListBillingGroupsResponseSuccess

      interface _ListCACertificatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCACertificatesResponse]
        def certificates: () -> ::Array[Types::CACertificate]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_ca_certificates-instance_method
      def list_ca_certificates: (
                                  ?page_size: ::Integer,
                                  ?marker: ::String,
                                  ?ascending_order: bool,
                                  ?template_name: ::String
                                ) -> _ListCACertificatesResponseSuccess
                              | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCACertificatesResponseSuccess

      interface _ListCertificateProvidersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCertificateProvidersResponse]
        def certificate_providers: () -> ::Array[Types::CertificateProviderSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_certificate_providers-instance_method
      def list_certificate_providers: (
                                        ?next_token: ::String,
                                        ?ascending_order: bool
                                      ) -> _ListCertificateProvidersResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCertificateProvidersResponseSuccess

      interface _ListCertificatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCertificatesResponse]
        def certificates: () -> ::Array[Types::Certificate]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_certificates-instance_method
      def list_certificates: (
                               ?page_size: ::Integer,
                               ?marker: ::String,
                               ?ascending_order: bool
                             ) -> _ListCertificatesResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCertificatesResponseSuccess

      interface _ListCertificatesByCAResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCertificatesByCAResponse]
        def certificates: () -> ::Array[Types::Certificate]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_certificates_by_ca-instance_method
      def list_certificates_by_ca: (
                                     ca_certificate_id: ::String,
                                     ?page_size: ::Integer,
                                     ?marker: ::String,
                                     ?ascending_order: bool
                                   ) -> _ListCertificatesByCAResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCertificatesByCAResponseSuccess

      interface _ListCommandExecutionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCommandExecutionsResponse]
        def command_executions: () -> ::Array[Types::CommandExecutionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_command_executions-instance_method
      def list_command_executions: (
                                     ?max_results: ::Integer,
                                     ?next_token: ::String,
                                     ?namespace: ("AWS-IoT" | "AWS-IoT-FleetWise"),
                                     ?status: ("CREATED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "REJECTED" | "TIMED_OUT"),
                                     ?sort_order: ("ASCENDING" | "DESCENDING"),
                                     ?started_time_filter: {
                                       after: ::String?,
                                       before: ::String?
                                     },
                                     ?completed_time_filter: {
                                       after: ::String?,
                                       before: ::String?
                                     },
                                     ?target_arn: ::String,
                                     ?command_arn: ::String
                                   ) -> _ListCommandExecutionsResponseSuccess
                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCommandExecutionsResponseSuccess

      interface _ListCommandsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCommandsResponse]
        def commands: () -> ::Array[Types::CommandSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_commands-instance_method
      def list_commands: (
                           ?max_results: ::Integer,
                           ?next_token: ::String,
                           ?namespace: ("AWS-IoT" | "AWS-IoT-FleetWise"),
                           ?command_parameter_name: ::String,
                           ?sort_order: ("ASCENDING" | "DESCENDING")
                         ) -> _ListCommandsResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCommandsResponseSuccess

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

      interface _ListDetectMitigationActionsExecutionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDetectMitigationActionsExecutionsResponse]
        def actions_executions: () -> ::Array[Types::DetectMitigationActionExecution]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_detect_mitigation_actions_executions-instance_method
      def list_detect_mitigation_actions_executions: (
                                                       ?task_id: ::String,
                                                       ?violation_id: ::String,
                                                       ?thing_name: ::String,
                                                       ?start_time: ::Time,
                                                       ?end_time: ::Time,
                                                       ?max_results: ::Integer,
                                                       ?next_token: ::String
                                                     ) -> _ListDetectMitigationActionsExecutionsResponseSuccess
                                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDetectMitigationActionsExecutionsResponseSuccess

      interface _ListDetectMitigationActionsTasksResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDetectMitigationActionsTasksResponse]
        def tasks: () -> ::Array[Types::DetectMitigationActionsTaskSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_detect_mitigation_actions_tasks-instance_method
      def list_detect_mitigation_actions_tasks: (
                                                  ?max_results: ::Integer,
                                                  ?next_token: ::String,
                                                  start_time: ::Time,
                                                  end_time: ::Time
                                                ) -> _ListDetectMitigationActionsTasksResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDetectMitigationActionsTasksResponseSuccess

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

      interface _ListDomainConfigurationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDomainConfigurationsResponse]
        def domain_configurations: () -> ::Array[Types::DomainConfigurationSummary]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_domain_configurations-instance_method
      def list_domain_configurations: (
                                        ?marker: ::String,
                                        ?page_size: ::Integer,
                                        ?service_type: ("DATA" | "CREDENTIAL_PROVIDER" | "JOBS")
                                      ) -> _ListDomainConfigurationsResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDomainConfigurationsResponseSuccess

      interface _ListFleetMetricsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListFleetMetricsResponse]
        def fleet_metrics: () -> ::Array[Types::FleetMetricNameAndArn]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_fleet_metrics-instance_method
      def list_fleet_metrics: (
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _ListFleetMetricsResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListFleetMetricsResponseSuccess

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

      interface _ListJobExecutionsForJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListJobExecutionsForJobResponse]
        def execution_summaries: () -> ::Array[Types::JobExecutionSummaryForJob]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_job_executions_for_job-instance_method
      def list_job_executions_for_job: (
                                         job_id: ::String,
                                         ?status: ("QUEUED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "TIMED_OUT" | "REJECTED" | "REMOVED" | "CANCELED"),
                                         ?max_results: ::Integer,
                                         ?next_token: ::String
                                       ) -> _ListJobExecutionsForJobResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListJobExecutionsForJobResponseSuccess

      interface _ListJobExecutionsForThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListJobExecutionsForThingResponse]
        def execution_summaries: () -> ::Array[Types::JobExecutionSummaryForThing]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_job_executions_for_thing-instance_method
      def list_job_executions_for_thing: (
                                           thing_name: ::String,
                                           ?status: ("QUEUED" | "IN_PROGRESS" | "SUCCEEDED" | "FAILED" | "TIMED_OUT" | "REJECTED" | "REMOVED" | "CANCELED"),
                                           ?namespace_id: ::String,
                                           ?max_results: ::Integer,
                                           ?next_token: ::String,
                                           ?job_id: ::String
                                         ) -> _ListJobExecutionsForThingResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListJobExecutionsForThingResponseSuccess

      interface _ListJobTemplatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListJobTemplatesResponse]
        def job_templates: () -> ::Array[Types::JobTemplateSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_job_templates-instance_method
      def list_job_templates: (
                                ?max_results: ::Integer,
                                ?next_token: ::String
                              ) -> _ListJobTemplatesResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListJobTemplatesResponseSuccess

      interface _ListJobsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListJobsResponse]
        def jobs: () -> ::Array[Types::JobSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_jobs-instance_method
      def list_jobs: (
                       ?status: ("IN_PROGRESS" | "CANCELED" | "COMPLETED" | "DELETION_IN_PROGRESS" | "SCHEDULED"),
                       ?target_selection: ("CONTINUOUS" | "SNAPSHOT"),
                       ?max_results: ::Integer,
                       ?next_token: ::String,
                       ?thing_group_name: ::String,
                       ?thing_group_id: ::String,
                       ?namespace_id: ::String
                     ) -> _ListJobsResponseSuccess
                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListJobsResponseSuccess

      interface _ListManagedJobTemplatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListManagedJobTemplatesResponse]
        def managed_job_templates: () -> ::Array[Types::ManagedJobTemplateSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_managed_job_templates-instance_method
      def list_managed_job_templates: (
                                        ?template_name: ::String,
                                        ?max_results: ::Integer,
                                        ?next_token: ::String
                                      ) -> _ListManagedJobTemplatesResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListManagedJobTemplatesResponseSuccess

      interface _ListMetricValuesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListMetricValuesResponse]
        def metric_datum_list: () -> ::Array[Types::MetricDatum]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_metric_values-instance_method
      def list_metric_values: (
                                thing_name: ::String,
                                metric_name: ::String,
                                ?dimension_name: ::String,
                                ?dimension_value_operator: ("IN" | "NOT_IN"),
                                start_time: ::Time,
                                end_time: ::Time,
                                ?max_results: ::Integer,
                                ?next_token: ::String
                              ) -> _ListMetricValuesResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListMetricValuesResponseSuccess

      interface _ListMitigationActionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListMitigationActionsResponse]
        def action_identifiers: () -> ::Array[Types::MitigationActionIdentifier]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_mitigation_actions-instance_method
      def list_mitigation_actions: (
                                     ?action_type: ("UPDATE_DEVICE_CERTIFICATE" | "UPDATE_CA_CERTIFICATE" | "ADD_THINGS_TO_THING_GROUP" | "REPLACE_DEFAULT_POLICY_VERSION" | "ENABLE_IOT_LOGGING" | "PUBLISH_FINDING_TO_SNS"),
                                     ?max_results: ::Integer,
                                     ?next_token: ::String
                                   ) -> _ListMitigationActionsResponseSuccess
                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListMitigationActionsResponseSuccess

      interface _ListOTAUpdatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListOTAUpdatesResponse]
        def ota_updates: () -> ::Array[Types::OTAUpdateSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_ota_updates-instance_method
      def list_ota_updates: (
                              ?max_results: ::Integer,
                              ?next_token: ::String,
                              ?ota_update_status: ("CREATE_PENDING" | "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "CREATE_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_FAILED")
                            ) -> _ListOTAUpdatesResponseSuccess
                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListOTAUpdatesResponseSuccess

      interface _ListOutgoingCertificatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListOutgoingCertificatesResponse]
        def outgoing_certificates: () -> ::Array[Types::OutgoingCertificate]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_outgoing_certificates-instance_method
      def list_outgoing_certificates: (
                                        ?page_size: ::Integer,
                                        ?marker: ::String,
                                        ?ascending_order: bool
                                      ) -> _ListOutgoingCertificatesResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListOutgoingCertificatesResponseSuccess

      interface _ListPackageVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPackageVersionsResponse]
        def package_version_summaries: () -> ::Array[Types::PackageVersionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_package_versions-instance_method
      def list_package_versions: (
                                   package_name: ::String,
                                   ?status: ("DRAFT" | "PUBLISHED" | "DEPRECATED"),
                                   ?max_results: ::Integer,
                                   ?next_token: ::String
                                 ) -> _ListPackageVersionsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPackageVersionsResponseSuccess

      interface _ListPackagesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPackagesResponse]
        def package_summaries: () -> ::Array[Types::PackageSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_packages-instance_method
      def list_packages: (
                           ?max_results: ::Integer,
                           ?next_token: ::String
                         ) -> _ListPackagesResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPackagesResponseSuccess

      interface _ListPoliciesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPoliciesResponse]
        def policies: () -> ::Array[Types::Policy]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_policies-instance_method
      def list_policies: (
                           ?marker: ::String,
                           ?page_size: ::Integer,
                           ?ascending_order: bool
                         ) -> _ListPoliciesResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPoliciesResponseSuccess

      interface _ListPolicyPrincipalsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPolicyPrincipalsResponse]
        def principals: () -> ::Array[::String]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_policy_principals-instance_method
      def list_policy_principals: (
                                    policy_name: ::String,
                                    ?marker: ::String,
                                    ?page_size: ::Integer,
                                    ?ascending_order: bool
                                  ) -> _ListPolicyPrincipalsResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPolicyPrincipalsResponseSuccess

      interface _ListPolicyVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPolicyVersionsResponse]
        def policy_versions: () -> ::Array[Types::PolicyVersion]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_policy_versions-instance_method
      def list_policy_versions: (
                                  policy_name: ::String
                                ) -> _ListPolicyVersionsResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPolicyVersionsResponseSuccess

      interface _ListPrincipalPoliciesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPrincipalPoliciesResponse]
        def policies: () -> ::Array[Types::Policy]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_principal_policies-instance_method
      def list_principal_policies: (
                                     principal: ::String,
                                     ?marker: ::String,
                                     ?page_size: ::Integer,
                                     ?ascending_order: bool
                                   ) -> _ListPrincipalPoliciesResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPrincipalPoliciesResponseSuccess

      interface _ListPrincipalThingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPrincipalThingsResponse]
        def things: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_principal_things-instance_method
      def list_principal_things: (
                                   ?next_token: ::String,
                                   ?max_results: ::Integer,
                                   principal: ::String
                                 ) -> _ListPrincipalThingsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPrincipalThingsResponseSuccess

      interface _ListPrincipalThingsV2ResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListPrincipalThingsV2Response]
        def principal_thing_objects: () -> ::Array[Types::PrincipalThingObject]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_principal_things_v2-instance_method
      def list_principal_things_v2: (
                                      ?next_token: ::String,
                                      ?max_results: ::Integer,
                                      principal: ::String,
                                      ?thing_principal_type: ("EXCLUSIVE_THING" | "NON_EXCLUSIVE_THING")
                                    ) -> _ListPrincipalThingsV2ResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPrincipalThingsV2ResponseSuccess

      interface _ListProvisioningTemplateVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListProvisioningTemplateVersionsResponse]
        def versions: () -> ::Array[Types::ProvisioningTemplateVersionSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_provisioning_template_versions-instance_method
      def list_provisioning_template_versions: (
                                                 template_name: ::String,
                                                 ?max_results: ::Integer,
                                                 ?next_token: ::String
                                               ) -> _ListProvisioningTemplateVersionsResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListProvisioningTemplateVersionsResponseSuccess

      interface _ListProvisioningTemplatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListProvisioningTemplatesResponse]
        def templates: () -> ::Array[Types::ProvisioningTemplateSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_provisioning_templates-instance_method
      def list_provisioning_templates: (
                                         ?max_results: ::Integer,
                                         ?next_token: ::String
                                       ) -> _ListProvisioningTemplatesResponseSuccess
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListProvisioningTemplatesResponseSuccess

      interface _ListRelatedResourcesForAuditFindingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRelatedResourcesForAuditFindingResponse]
        def related_resources: () -> ::Array[Types::RelatedResource]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_related_resources_for_audit_finding-instance_method
      def list_related_resources_for_audit_finding: (
                                                      finding_id: ::String,
                                                      ?next_token: ::String,
                                                      ?max_results: ::Integer
                                                    ) -> _ListRelatedResourcesForAuditFindingResponseSuccess
                                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRelatedResourcesForAuditFindingResponseSuccess

      interface _ListRoleAliasesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListRoleAliasesResponse]
        def role_aliases: () -> ::Array[::String]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_role_aliases-instance_method
      def list_role_aliases: (
                               ?page_size: ::Integer,
                               ?marker: ::String,
                               ?ascending_order: bool
                             ) -> _ListRoleAliasesResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListRoleAliasesResponseSuccess

      interface _ListSbomValidationResultsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSbomValidationResultsResponse]
        def validation_result_summaries: () -> ::Array[Types::SbomValidationResultSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_sbom_validation_results-instance_method
      def list_sbom_validation_results: (
                                          package_name: ::String,
                                          version_name: ::String,
                                          ?validation_result: ("FAILED" | "SUCCEEDED"),
                                          ?max_results: ::Integer,
                                          ?next_token: ::String
                                        ) -> _ListSbomValidationResultsResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSbomValidationResultsResponseSuccess

      interface _ListScheduledAuditsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListScheduledAuditsResponse]
        def scheduled_audits: () -> ::Array[Types::ScheduledAuditMetadata]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_scheduled_audits-instance_method
      def list_scheduled_audits: (
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _ListScheduledAuditsResponseSuccess
                               | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListScheduledAuditsResponseSuccess

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

      interface _ListSecurityProfilesForTargetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSecurityProfilesForTargetResponse]
        def security_profile_target_mappings: () -> ::Array[Types::SecurityProfileTargetMapping]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_security_profiles_for_target-instance_method
      def list_security_profiles_for_target: (
                                               ?next_token: ::String,
                                               ?max_results: ::Integer,
                                               ?recursive: bool,
                                               security_profile_target_arn: ::String
                                             ) -> _ListSecurityProfilesForTargetResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSecurityProfilesForTargetResponseSuccess

      interface _ListStreamsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListStreamsResponse]
        def streams: () -> ::Array[Types::StreamSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_streams-instance_method
      def list_streams: (
                          ?max_results: ::Integer,
                          ?next_token: ::String,
                          ?ascending_order: bool
                        ) -> _ListStreamsResponseSuccess
                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListStreamsResponseSuccess

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

      interface _ListTargetsForPolicyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTargetsForPolicyResponse]
        def targets: () -> ::Array[::String]
        def next_marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_targets_for_policy-instance_method
      def list_targets_for_policy: (
                                     policy_name: ::String,
                                     ?marker: ::String,
                                     ?page_size: ::Integer
                                   ) -> _ListTargetsForPolicyResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTargetsForPolicyResponseSuccess

      interface _ListTargetsForSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTargetsForSecurityProfileResponse]
        def security_profile_targets: () -> ::Array[Types::SecurityProfileTarget]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_targets_for_security_profile-instance_method
      def list_targets_for_security_profile: (
                                               security_profile_name: ::String,
                                               ?next_token: ::String,
                                               ?max_results: ::Integer
                                             ) -> _ListTargetsForSecurityProfileResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTargetsForSecurityProfileResponseSuccess

      interface _ListThingGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingGroupsResponse]
        def thing_groups: () -> ::Array[Types::GroupNameAndArn]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_groups-instance_method
      def list_thing_groups: (
                               ?next_token: ::String,
                               ?max_results: ::Integer,
                               ?parent_group: ::String,
                               ?name_prefix_filter: ::String,
                               ?recursive: bool
                             ) -> _ListThingGroupsResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingGroupsResponseSuccess

      interface _ListThingGroupsForThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingGroupsForThingResponse]
        def thing_groups: () -> ::Array[Types::GroupNameAndArn]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_groups_for_thing-instance_method
      def list_thing_groups_for_thing: (
                                         thing_name: ::String,
                                         ?next_token: ::String,
                                         ?max_results: ::Integer
                                       ) -> _ListThingGroupsForThingResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingGroupsForThingResponseSuccess

      interface _ListThingPrincipalsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingPrincipalsResponse]
        def principals: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_principals-instance_method
      def list_thing_principals: (
                                   ?next_token: ::String,
                                   ?max_results: ::Integer,
                                   thing_name: ::String
                                 ) -> _ListThingPrincipalsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingPrincipalsResponseSuccess

      interface _ListThingPrincipalsV2ResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingPrincipalsV2Response]
        def thing_principal_objects: () -> ::Array[Types::ThingPrincipalObject]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_principals_v2-instance_method
      def list_thing_principals_v2: (
                                      ?next_token: ::String,
                                      ?max_results: ::Integer,
                                      thing_name: ::String,
                                      ?thing_principal_type: ("EXCLUSIVE_THING" | "NON_EXCLUSIVE_THING")
                                    ) -> _ListThingPrincipalsV2ResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingPrincipalsV2ResponseSuccess

      interface _ListThingRegistrationTaskReportsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingRegistrationTaskReportsResponse]
        def resource_links: () -> ::Array[::String]
        def report_type: () -> ("ERRORS" | "RESULTS")
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_registration_task_reports-instance_method
      def list_thing_registration_task_reports: (
                                                  task_id: ::String,
                                                  report_type: ("ERRORS" | "RESULTS"),
                                                  ?next_token: ::String,
                                                  ?max_results: ::Integer
                                                ) -> _ListThingRegistrationTaskReportsResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingRegistrationTaskReportsResponseSuccess

      interface _ListThingRegistrationTasksResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingRegistrationTasksResponse]
        def task_ids: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_registration_tasks-instance_method
      def list_thing_registration_tasks: (
                                           ?next_token: ::String,
                                           ?max_results: ::Integer,
                                           ?status: ("InProgress" | "Completed" | "Failed" | "Cancelled" | "Cancelling")
                                         ) -> _ListThingRegistrationTasksResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingRegistrationTasksResponseSuccess

      interface _ListThingTypesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingTypesResponse]
        def thing_types: () -> ::Array[Types::ThingTypeDefinition]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_thing_types-instance_method
      def list_thing_types: (
                              ?next_token: ::String,
                              ?max_results: ::Integer,
                              ?thing_type_name: ::String
                            ) -> _ListThingTypesResponseSuccess
                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingTypesResponseSuccess

      interface _ListThingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingsResponse]
        def things: () -> ::Array[Types::ThingAttribute]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_things-instance_method
      def list_things: (
                         ?next_token: ::String,
                         ?max_results: ::Integer,
                         ?attribute_name: ::String,
                         ?attribute_value: ::String,
                         ?thing_type_name: ::String,
                         ?use_prefix_attribute_value: bool
                       ) -> _ListThingsResponseSuccess
                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingsResponseSuccess

      interface _ListThingsInBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingsInBillingGroupResponse]
        def things: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_things_in_billing_group-instance_method
      def list_things_in_billing_group: (
                                          billing_group_name: ::String,
                                          ?next_token: ::String,
                                          ?max_results: ::Integer
                                        ) -> _ListThingsInBillingGroupResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingsInBillingGroupResponseSuccess

      interface _ListThingsInThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListThingsInThingGroupResponse]
        def things: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_things_in_thing_group-instance_method
      def list_things_in_thing_group: (
                                        thing_group_name: ::String,
                                        ?recursive: bool,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer
                                      ) -> _ListThingsInThingGroupResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListThingsInThingGroupResponseSuccess

      interface _ListTopicRuleDestinationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTopicRuleDestinationsResponse]
        def destination_summaries: () -> ::Array[Types::TopicRuleDestinationSummary]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_topic_rule_destinations-instance_method
      def list_topic_rule_destinations: (
                                          ?max_results: ::Integer,
                                          ?next_token: ::String
                                        ) -> _ListTopicRuleDestinationsResponseSuccess
                                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTopicRuleDestinationsResponseSuccess

      interface _ListTopicRulesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTopicRulesResponse]
        def rules: () -> ::Array[Types::TopicRuleListItem]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_topic_rules-instance_method
      def list_topic_rules: (
                              ?topic: ::String,
                              ?max_results: ::Integer,
                              ?next_token: ::String,
                              ?rule_disabled: bool
                            ) -> _ListTopicRulesResponseSuccess
                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTopicRulesResponseSuccess

      interface _ListV2LoggingLevelsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListV2LoggingLevelsResponse]
        def log_target_configurations: () -> ::Array[Types::LogTargetConfiguration]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_v2_logging_levels-instance_method
      def list_v2_logging_levels: (
                                    ?target_type: ("DEFAULT" | "THING_GROUP" | "CLIENT_ID" | "SOURCE_IP" | "PRINCIPAL_ID"),
                                    ?next_token: ::String,
                                    ?max_results: ::Integer
                                  ) -> _ListV2LoggingLevelsResponseSuccess
                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListV2LoggingLevelsResponseSuccess

      interface _ListViolationEventsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListViolationEventsResponse]
        def violation_events: () -> ::Array[Types::ViolationEvent]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#list_violation_events-instance_method
      def list_violation_events: (
                                   start_time: ::Time,
                                   end_time: ::Time,
                                   ?thing_name: ::String,
                                   ?security_profile_name: ::String,
                                   ?behavior_criteria_type: ("STATIC" | "STATISTICAL" | "MACHINE_LEARNING"),
                                   ?list_suppressed_alerts: bool,
                                   ?verification_state: ("FALSE_POSITIVE" | "BENIGN_POSITIVE" | "TRUE_POSITIVE" | "UNKNOWN"),
                                   ?next_token: ::String,
                                   ?max_results: ::Integer
                                 ) -> _ListViolationEventsResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListViolationEventsResponseSuccess

      interface _PutVerificationStateOnViolationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PutVerificationStateOnViolationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#put_verification_state_on_violation-instance_method
      def put_verification_state_on_violation: (
                                                 violation_id: ::String,
                                                 verification_state: ("FALSE_POSITIVE" | "BENIGN_POSITIVE" | "TRUE_POSITIVE" | "UNKNOWN"),
                                                 ?verification_state_description: ::String
                                               ) -> _PutVerificationStateOnViolationResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutVerificationStateOnViolationResponseSuccess

      interface _RegisterCACertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RegisterCACertificateResponse]
        def certificate_arn: () -> ::String
        def certificate_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#register_ca_certificate-instance_method
      def register_ca_certificate: (
                                     ca_certificate: ::String,
                                     ?verification_certificate: ::String,
                                     ?set_as_active: bool,
                                     ?allow_auto_registration: bool,
                                     ?registration_config: {
                                       template_body: ::String?,
                                       role_arn: ::String?,
                                       template_name: ::String?
                                     },
                                     ?tags: Array[
                                       {
                                         key: ::String,
                                         value: ::String?
                                       },
                                     ],
                                     ?certificate_mode: ("DEFAULT" | "SNI_ONLY")
                                   ) -> _RegisterCACertificateResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterCACertificateResponseSuccess

      interface _RegisterCertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RegisterCertificateResponse]
        def certificate_arn: () -> ::String
        def certificate_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#register_certificate-instance_method
      def register_certificate: (
                                  certificate_pem: ::String,
                                  ?ca_certificate_pem: ::String,
                                  ?set_as_active: bool,
                                  ?status: ("ACTIVE" | "INACTIVE" | "REVOKED" | "PENDING_TRANSFER" | "REGISTER_INACTIVE" | "PENDING_ACTIVATION")
                                ) -> _RegisterCertificateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterCertificateResponseSuccess

      interface _RegisterCertificateWithoutCAResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RegisterCertificateWithoutCAResponse]
        def certificate_arn: () -> ::String
        def certificate_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#register_certificate_without_ca-instance_method
      def register_certificate_without_ca: (
                                             certificate_pem: ::String,
                                             ?status: ("ACTIVE" | "INACTIVE" | "REVOKED" | "PENDING_TRANSFER" | "REGISTER_INACTIVE" | "PENDING_ACTIVATION")
                                           ) -> _RegisterCertificateWithoutCAResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterCertificateWithoutCAResponseSuccess

      interface _RegisterThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RegisterThingResponse]
        def certificate_pem: () -> ::String
        def resource_arns: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#register_thing-instance_method
      def register_thing: (
                            template_body: ::String,
                            ?parameters: Hash[::String, ::String]
                          ) -> _RegisterThingResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterThingResponseSuccess

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

      interface _RemoveThingFromBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RemoveThingFromBillingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#remove_thing_from_billing_group-instance_method
      def remove_thing_from_billing_group: (
                                             ?billing_group_name: ::String,
                                             ?billing_group_arn: ::String,
                                             ?thing_name: ::String,
                                             ?thing_arn: ::String
                                           ) -> _RemoveThingFromBillingGroupResponseSuccess
                                         | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RemoveThingFromBillingGroupResponseSuccess

      interface _RemoveThingFromThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RemoveThingFromThingGroupResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#remove_thing_from_thing_group-instance_method
      def remove_thing_from_thing_group: (
                                           ?thing_group_name: ::String,
                                           ?thing_group_arn: ::String,
                                           ?thing_name: ::String,
                                           ?thing_arn: ::String
                                         ) -> _RemoveThingFromThingGroupResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RemoveThingFromThingGroupResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#replace_topic_rule-instance_method
      def replace_topic_rule: (
                                rule_name: ::String,
                                topic_rule_payload: {
                                  sql: ::String,
                                  description: ::String?,
                                  actions: Array[
                                    {
                                      dynamo_db: {
                                        table_name: ::String,
                                        role_arn: ::String,
                                        operation: ::String?,
                                        hash_key_field: ::String,
                                        hash_key_value: ::String,
                                        hash_key_type: ("STRING" | "NUMBER")?,
                                        range_key_field: ::String?,
                                        range_key_value: ::String?,
                                        range_key_type: ("STRING" | "NUMBER")?,
                                        payload_field: ::String?
                                      }?,
                                      dynamo_d_bv_2: {
                                        role_arn: ::String,
                                        put_item: {
                                          table_name: ::String
                                        }
                                      }?,
                                      lambda: {
                                        function_arn: ::String
                                      }?,
                                      sns: {
                                        target_arn: ::String,
                                        role_arn: ::String,
                                        message_format: ("RAW" | "JSON")?
                                      }?,
                                      sqs: {
                                        role_arn: ::String,
                                        queue_url: ::String,
                                        use_base_64: bool?
                                      }?,
                                      kinesis: {
                                        role_arn: ::String,
                                        stream_name: ::String,
                                        partition_key: ::String?
                                      }?,
                                      republish: {
                                        role_arn: ::String,
                                        topic: ::String,
                                        qos: ::Integer?,
                                        headers: {
                                          payload_format_indicator: ::String?,
                                          content_type: ::String?,
                                          response_topic: ::String?,
                                          correlation_data: ::String?,
                                          message_expiry: ::String?,
                                          user_properties: Array[
                                            {
                                              key: ::String,
                                              value: ::String
                                            },
                                          ]?
                                        }?
                                      }?,
                                      s3: {
                                        role_arn: ::String,
                                        bucket_name: ::String,
                                        key: ::String,
                                        canned_acl: ("private" | "public-read" | "public-read-write" | "aws-exec-read" | "authenticated-read" | "bucket-owner-read" | "bucket-owner-full-control" | "log-delivery-write")?
                                      }?,
                                      firehose: {
                                        role_arn: ::String,
                                        delivery_stream_name: ::String,
                                        separator: ::String?,
                                        batch_mode: bool?
                                      }?,
                                      cloudwatch_metric: {
                                        role_arn: ::String,
                                        metric_namespace: ::String,
                                        metric_name: ::String,
                                        metric_value: ::String,
                                        metric_unit: ::String,
                                        metric_timestamp: ::String?
                                      }?,
                                      cloudwatch_alarm: {
                                        role_arn: ::String,
                                        alarm_name: ::String,
                                        state_reason: ::String,
                                        state_value: ::String
                                      }?,
                                      cloudwatch_logs: {
                                        role_arn: ::String,
                                        log_group_name: ::String,
                                        batch_mode: bool?
                                      }?,
                                      elasticsearch: {
                                        role_arn: ::String,
                                        endpoint: ::String,
                                        index: ::String,
                                        type: ::String,
                                        id: ::String
                                      }?,
                                      salesforce: {
                                        token: ::String,
                                        url: ::String
                                      }?,
                                      iot_analytics: {
                                        channel_arn: ::String?,
                                        channel_name: ::String?,
                                        batch_mode: bool?,
                                        role_arn: ::String?
                                      }?,
                                      iot_events: {
                                        input_name: ::String,
                                        message_id: ::String?,
                                        batch_mode: bool?,
                                        role_arn: ::String
                                      }?,
                                      iot_site_wise: {
                                        put_asset_property_value_entries: Array[
                                          {
                                            entry_id: ::String?,
                                            asset_id: ::String?,
                                            property_id: ::String?,
                                            property_alias: ::String?,
                                            property_values: Array[
                                              {
                                                value: {
                                                  string_value: ::String?,
                                                  integer_value: ::String?,
                                                  double_value: ::String?,
                                                  boolean_value: ::String?
                                                },
                                                timestamp: {
                                                  time_in_seconds: ::String,
                                                  offset_in_nanos: ::String?
                                                },
                                                quality: ::String?
                                              },
                                            ]
                                          },
                                        ],
                                        role_arn: ::String
                                      }?,
                                      step_functions: {
                                        execution_name_prefix: ::String?,
                                        state_machine_name: ::String,
                                        role_arn: ::String
                                      }?,
                                      timestream: {
                                        role_arn: ::String,
                                        database_name: ::String,
                                        table_name: ::String,
                                        dimensions: Array[
                                          {
                                            name: ::String,
                                            value: ::String
                                          },
                                        ],
                                        timestamp: {
                                          value: ::String,
                                          unit: ::String
                                        }?
                                      }?,
                                      http: {
                                        url: ::String,
                                        confirmation_url: ::String?,
                                        headers: Array[
                                          {
                                            key: ::String,
                                            value: ::String
                                          },
                                        ]?,
                                        auth: {
                                          sigv4: {
                                            signing_region: ::String,
                                            service_name: ::String,
                                            role_arn: ::String
                                          }?
                                        }?
                                      }?,
                                      kafka: {
                                        destination_arn: ::String,
                                        topic: ::String,
                                        key: ::String?,
                                        partition: ::String?,
                                        client_properties: Hash[::String, ::String],
                                        headers: Array[
                                          {
                                            key: ::String,
                                            value: ::String
                                          },
                                        ]?
                                      }?,
                                      open_search: {
                                        role_arn: ::String,
                                        endpoint: ::String,
                                        index: ::String,
                                        type: ::String,
                                        id: ::String
                                      }?,
                                      location: {
                                        role_arn: ::String,
                                        tracker_name: ::String,
                                        device_id: ::String,
                                        timestamp: {
                                          value: ::String,
                                          unit: ::String?
                                        }?,
                                        latitude: ::String,
                                        longitude: ::String
                                      }?
                                    },
                                  ],
                                  rule_disabled: bool?,
                                  aws_iot_sql_version: ::String?,
                                  error_action: {
                                    dynamo_db: {
                                      table_name: ::String,
                                      role_arn: ::String,
                                      operation: ::String?,
                                      hash_key_field: ::String,
                                      hash_key_value: ::String,
                                      hash_key_type: ("STRING" | "NUMBER")?,
                                      range_key_field: ::String?,
                                      range_key_value: ::String?,
                                      range_key_type: ("STRING" | "NUMBER")?,
                                      payload_field: ::String?
                                    }?,
                                    dynamo_d_bv_2: {
                                      role_arn: ::String,
                                      put_item: {
                                        table_name: ::String
                                      }
                                    }?,
                                    lambda: {
                                      function_arn: ::String
                                    }?,
                                    sns: {
                                      target_arn: ::String,
                                      role_arn: ::String,
                                      message_format: ("RAW" | "JSON")?
                                    }?,
                                    sqs: {
                                      role_arn: ::String,
                                      queue_url: ::String,
                                      use_base_64: bool?
                                    }?,
                                    kinesis: {
                                      role_arn: ::String,
                                      stream_name: ::String,
                                      partition_key: ::String?
                                    }?,
                                    republish: {
                                      role_arn: ::String,
                                      topic: ::String,
                                      qos: ::Integer?,
                                      headers: {
                                        payload_format_indicator: ::String?,
                                        content_type: ::String?,
                                        response_topic: ::String?,
                                        correlation_data: ::String?,
                                        message_expiry: ::String?,
                                        user_properties: Array[
                                          {
                                            key: ::String,
                                            value: ::String
                                          },
                                        ]?
                                      }?
                                    }?,
                                    s3: {
                                      role_arn: ::String,
                                      bucket_name: ::String,
                                      key: ::String,
                                      canned_acl: ("private" | "public-read" | "public-read-write" | "aws-exec-read" | "authenticated-read" | "bucket-owner-read" | "bucket-owner-full-control" | "log-delivery-write")?
                                    }?,
                                    firehose: {
                                      role_arn: ::String,
                                      delivery_stream_name: ::String,
                                      separator: ::String?,
                                      batch_mode: bool?
                                    }?,
                                    cloudwatch_metric: {
                                      role_arn: ::String,
                                      metric_namespace: ::String,
                                      metric_name: ::String,
                                      metric_value: ::String,
                                      metric_unit: ::String,
                                      metric_timestamp: ::String?
                                    }?,
                                    cloudwatch_alarm: {
                                      role_arn: ::String,
                                      alarm_name: ::String,
                                      state_reason: ::String,
                                      state_value: ::String
                                    }?,
                                    cloudwatch_logs: {
                                      role_arn: ::String,
                                      log_group_name: ::String,
                                      batch_mode: bool?
                                    }?,
                                    elasticsearch: {
                                      role_arn: ::String,
                                      endpoint: ::String,
                                      index: ::String,
                                      type: ::String,
                                      id: ::String
                                    }?,
                                    salesforce: {
                                      token: ::String,
                                      url: ::String
                                    }?,
                                    iot_analytics: {
                                      channel_arn: ::String?,
                                      channel_name: ::String?,
                                      batch_mode: bool?,
                                      role_arn: ::String?
                                    }?,
                                    iot_events: {
                                      input_name: ::String,
                                      message_id: ::String?,
                                      batch_mode: bool?,
                                      role_arn: ::String
                                    }?,
                                    iot_site_wise: {
                                      put_asset_property_value_entries: Array[
                                        {
                                          entry_id: ::String?,
                                          asset_id: ::String?,
                                          property_id: ::String?,
                                          property_alias: ::String?,
                                          property_values: Array[
                                            {
                                              value: {
                                                string_value: ::String?,
                                                integer_value: ::String?,
                                                double_value: ::String?,
                                                boolean_value: ::String?
                                              },
                                              timestamp: {
                                                time_in_seconds: ::String,
                                                offset_in_nanos: ::String?
                                              },
                                              quality: ::String?
                                            },
                                          ]
                                        },
                                      ],
                                      role_arn: ::String
                                    }?,
                                    step_functions: {
                                      execution_name_prefix: ::String?,
                                      state_machine_name: ::String,
                                      role_arn: ::String
                                    }?,
                                    timestream: {
                                      role_arn: ::String,
                                      database_name: ::String,
                                      table_name: ::String,
                                      dimensions: Array[
                                        {
                                          name: ::String,
                                          value: ::String
                                        },
                                      ],
                                      timestamp: {
                                        value: ::String,
                                        unit: ::String
                                      }?
                                    }?,
                                    http: {
                                      url: ::String,
                                      confirmation_url: ::String?,
                                      headers: Array[
                                        {
                                          key: ::String,
                                          value: ::String
                                        },
                                      ]?,
                                      auth: {
                                        sigv4: {
                                          signing_region: ::String,
                                          service_name: ::String,
                                          role_arn: ::String
                                        }?
                                      }?
                                    }?,
                                    kafka: {
                                      destination_arn: ::String,
                                      topic: ::String,
                                      key: ::String?,
                                      partition: ::String?,
                                      client_properties: Hash[::String, ::String],
                                      headers: Array[
                                        {
                                          key: ::String,
                                          value: ::String
                                        },
                                      ]?
                                    }?,
                                    open_search: {
                                      role_arn: ::String,
                                      endpoint: ::String,
                                      index: ::String,
                                      type: ::String,
                                      id: ::String
                                    }?,
                                    location: {
                                      role_arn: ::String,
                                      tracker_name: ::String,
                                      device_id: ::String,
                                      timestamp: {
                                        value: ::String,
                                        unit: ::String?
                                      }?,
                                      latitude: ::String,
                                      longitude: ::String
                                    }?
                                  }?
                                }
                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _SearchIndexResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchIndexResponse]
        def next_token: () -> ::String
        def things: () -> ::Array[Types::ThingDocument]
        def thing_groups: () -> ::Array[Types::ThingGroupDocument]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#search_index-instance_method
      def search_index: (
                          ?index_name: ::String,
                          query_string: ::String,
                          ?next_token: ::String,
                          ?max_results: ::Integer,
                          ?query_version: ::String
                        ) -> _SearchIndexResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchIndexResponseSuccess

      interface _SetDefaultAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SetDefaultAuthorizerResponse]
        def authorizer_name: () -> ::String
        def authorizer_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#set_default_authorizer-instance_method
      def set_default_authorizer: (
                                    authorizer_name: ::String
                                  ) -> _SetDefaultAuthorizerResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SetDefaultAuthorizerResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#set_default_policy_version-instance_method
      def set_default_policy_version: (
                                        policy_name: ::String,
                                        policy_version_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/IoT/Client.html#set_logging_options-instance_method
      def set_logging_options: (
                                 logging_options_payload: {
                                   role_arn: ::String,
                                   log_level: ("DEBUG" | "INFO" | "ERROR" | "WARN" | "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/IoT/Client.html#set_v2_logging_level-instance_method
      def set_v2_logging_level: (
                                  log_target: {
                                    target_type: ("DEFAULT" | "THING_GROUP" | "CLIENT_ID" | "SOURCE_IP" | "PRINCIPAL_ID"),
                                    target_name: ::String?
                                  },
                                  log_level: ("DEBUG" | "INFO" | "ERROR" | "WARN" | "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/IoT/Client.html#set_v2_logging_options-instance_method
      def set_v2_logging_options: (
                                    ?role_arn: ::String,
                                    ?default_log_level: ("DEBUG" | "INFO" | "ERROR" | "WARN" | "DISABLED"),
                                    ?disable_all_logs: bool
                                  ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _StartAuditMitigationActionsTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartAuditMitigationActionsTaskResponse]
        def task_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#start_audit_mitigation_actions_task-instance_method
      def start_audit_mitigation_actions_task: (
                                                 task_id: ::String,
                                                 target: {
                                                   audit_task_id: ::String?,
                                                   finding_ids: Array[::String]?,
                                                   audit_check_to_reason_code_filter: Hash[::String, Array[::String]]?
                                                 },
                                                 audit_check_to_actions_mapping: Hash[::String, Array[::String]],
                                                 client_request_token: ::String
                                               ) -> _StartAuditMitigationActionsTaskResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartAuditMitigationActionsTaskResponseSuccess

      interface _StartDetectMitigationActionsTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartDetectMitigationActionsTaskResponse]
        def task_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#start_detect_mitigation_actions_task-instance_method
      def start_detect_mitigation_actions_task: (
                                                  task_id: ::String,
                                                  target: {
                                                    violation_ids: Array[::String]?,
                                                    security_profile_name: ::String?,
                                                    behavior_name: ::String?
                                                  },
                                                  actions: Array[::String],
                                                  ?violation_event_occurrence_range: {
                                                    start_time: ::Time,
                                                    end_time: ::Time
                                                  },
                                                  ?include_only_active_violations: bool,
                                                  ?include_suppressed_alerts: bool,
                                                  client_request_token: ::String
                                                ) -> _StartDetectMitigationActionsTaskResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartDetectMitigationActionsTaskResponseSuccess

      interface _StartOnDemandAuditTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartOnDemandAuditTaskResponse]
        def task_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#start_on_demand_audit_task-instance_method
      def start_on_demand_audit_task: (
                                        target_check_names: Array[::String]
                                      ) -> _StartOnDemandAuditTaskResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartOnDemandAuditTaskResponseSuccess

      interface _StartThingRegistrationTaskResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartThingRegistrationTaskResponse]
        def task_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#start_thing_registration_task-instance_method
      def start_thing_registration_task: (
                                           template_body: ::String,
                                           input_file_bucket: ::String,
                                           input_file_key: ::String,
                                           role_arn: ::String
                                         ) -> _StartThingRegistrationTaskResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartThingRegistrationTaskResponseSuccess

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

      interface _TagResourceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TagResourceResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#tag_resource-instance_method
      def tag_resource: (
                          resource_arn: ::String,
                          tags: Array[
                            {
                              key: ::String,
                              value: ::String?
                            },
                          ]
                        ) -> _TagResourceResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TagResourceResponseSuccess

      interface _TestAuthorizationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TestAuthorizationResponse]
        def auth_results: () -> ::Array[Types::AuthResult]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#test_authorization-instance_method
      def test_authorization: (
                                ?principal: ::String,
                                ?cognito_identity_pool_id: ::String,
                                auth_infos: Array[
                                  {
                                    action_type: ("PUBLISH" | "SUBSCRIBE" | "RECEIVE" | "CONNECT")?,
                                    resources: Array[::String]
                                  },
                                ],
                                ?client_id: ::String,
                                ?policy_names_to_add: Array[::String],
                                ?policy_names_to_skip: Array[::String]
                              ) -> _TestAuthorizationResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TestAuthorizationResponseSuccess

      interface _TestInvokeAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TestInvokeAuthorizerResponse]
        def is_authenticated: () -> bool
        def principal_id: () -> ::String
        def policy_documents: () -> ::Array[::String]
        def refresh_after_in_seconds: () -> ::Integer
        def disconnect_after_in_seconds: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#test_invoke_authorizer-instance_method
      def test_invoke_authorizer: (
                                    authorizer_name: ::String,
                                    ?token: ::String,
                                    ?token_signature: ::String,
                                    ?http_context: {
                                      headers: Hash[::String, ::String]?,
                                      query_string: ::String?
                                    },
                                    ?mqtt_context: {
                                      username: ::String?,
                                      password: ::String?,
                                      client_id: ::String?
                                    },
                                    ?tls_context: {
                                      server_name: ::String?
                                    }
                                  ) -> _TestInvokeAuthorizerResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TestInvokeAuthorizerResponseSuccess

      interface _TransferCertificateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TransferCertificateResponse]
        def transferred_certificate_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#transfer_certificate-instance_method
      def transfer_certificate: (
                                  certificate_id: ::String,
                                  target_aws_account: ::String,
                                  ?transfer_message: ::String
                                ) -> _TransferCertificateResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TransferCertificateResponseSuccess

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

      interface _UpdateAccountAuditConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateAccountAuditConfigurationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_account_audit_configuration-instance_method
      def update_account_audit_configuration: (
                                                ?role_arn: ::String,
                                                ?audit_notification_target_configurations: Hash[("SNS"), {
                                                    target_arn: ::String?,
                                                    role_arn: ::String?,
                                                    enabled: bool?
                                                  }],
                                                ?audit_check_configurations: Hash[::String, {
                                                    enabled: bool?
                                                  }]
                                              ) -> _UpdateAccountAuditConfigurationResponseSuccess
                                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateAccountAuditConfigurationResponseSuccess

      interface _UpdateAuditSuppressionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateAuditSuppressionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_audit_suppression-instance_method
      def update_audit_suppression: (
                                      check_name: ::String,
                                      resource_identifier: {
                                        device_certificate_id: ::String?,
                                        ca_certificate_id: ::String?,
                                        cognito_identity_pool_id: ::String?,
                                        client_id: ::String?,
                                        policy_version_identifier: {
                                          policy_name: ::String?,
                                          policy_version_id: ::String?
                                        }?,
                                        account: ::String?,
                                        iam_role_arn: ::String?,
                                        role_alias_arn: ::String?,
                                        issuer_certificate_identifier: {
                                          issuer_certificate_subject: ::String?,
                                          issuer_id: ::String?,
                                          issuer_certificate_serial_number: ::String?
                                        }?,
                                        device_certificate_arn: ::String?
                                      },
                                      ?expiration_date: ::Time,
                                      ?suppress_indefinitely: bool,
                                      ?description: ::String
                                    ) -> _UpdateAuditSuppressionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateAuditSuppressionResponseSuccess

      interface _UpdateAuthorizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateAuthorizerResponse]
        def authorizer_name: () -> ::String
        def authorizer_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_authorizer-instance_method
      def update_authorizer: (
                               authorizer_name: ::String,
                               ?authorizer_function_arn: ::String,
                               ?token_key_name: ::String,
                               ?token_signing_public_keys: Hash[::String, ::String],
                               ?status: ("ACTIVE" | "INACTIVE"),
                               ?enable_caching_for_http: bool
                             ) -> _UpdateAuthorizerResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateAuthorizerResponseSuccess

      interface _UpdateBillingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateBillingGroupResponse]
        def version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_billing_group-instance_method
      def update_billing_group: (
                                  billing_group_name: ::String,
                                  billing_group_properties: {
                                    billing_group_description: ::String?
                                  },
                                  ?expected_version: ::Integer
                                ) -> _UpdateBillingGroupResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateBillingGroupResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_ca_certificate-instance_method
      def update_ca_certificate: (
                                   certificate_id: ::String,
                                   ?new_status: ("ACTIVE" | "INACTIVE"),
                                   ?new_auto_registration_status: ("ENABLE" | "DISABLE"),
                                   ?registration_config: {
                                     template_body: ::String?,
                                     role_arn: ::String?,
                                     template_name: ::String?
                                   },
                                   ?remove_auto_registration: 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/IoT/Client.html#update_certificate-instance_method
      def update_certificate: (
                                certificate_id: ::String,
                                new_status: ("ACTIVE" | "INACTIVE" | "REVOKED" | "PENDING_TRANSFER" | "REGISTER_INACTIVE" | "PENDING_ACTIVATION")
                              ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateCertificateProviderResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateCertificateProviderResponse]
        def certificate_provider_name: () -> ::String
        def certificate_provider_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_certificate_provider-instance_method
      def update_certificate_provider: (
                                         certificate_provider_name: ::String,
                                         ?lambda_function_arn: ::String,
                                         ?account_default_for_operations: Array[("CreateCertificateFromCsr")]
                                       ) -> _UpdateCertificateProviderResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateCertificateProviderResponseSuccess

      interface _UpdateCommandResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateCommandResponse]
        def command_id: () -> ::String
        def display_name: () -> ::String
        def description: () -> ::String
        def deprecated: () -> bool
        def last_updated_at: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_command-instance_method
      def update_command: (
                            command_id: ::String,
                            ?display_name: ::String,
                            ?description: ::String,
                            ?deprecated: bool
                          ) -> _UpdateCommandResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateCommandResponseSuccess

      interface _UpdateCustomMetricResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateCustomMetricResponse]
        def metric_name: () -> ::String
        def metric_arn: () -> ::String
        def metric_type: () -> ("string-list" | "ip-address-list" | "number-list" | "number")
        def display_name: () -> ::String
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_custom_metric-instance_method
      def update_custom_metric: (
                                  metric_name: ::String,
                                  display_name: ::String
                                ) -> _UpdateCustomMetricResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateCustomMetricResponseSuccess

      interface _UpdateDimensionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDimensionResponse]
        def name: () -> ::String
        def arn: () -> ::String
        def type: () -> ("TOPIC_FILTER")
        def string_values: () -> ::Array[::String]
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_dimension-instance_method
      def update_dimension: (
                              name: ::String,
                              string_values: Array[::String]
                            ) -> _UpdateDimensionResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDimensionResponseSuccess

      interface _UpdateDomainConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDomainConfigurationResponse]
        def domain_configuration_name: () -> ::String
        def domain_configuration_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_domain_configuration-instance_method
      def update_domain_configuration: (
                                         domain_configuration_name: ::String,
                                         ?authorizer_config: {
                                           default_authorizer_name: ::String?,
                                           allow_authorizer_override: bool?
                                         },
                                         ?domain_configuration_status: ("ENABLED" | "DISABLED"),
                                         ?remove_authorizer_config: bool,
                                         ?tls_config: {
                                           security_policy: ::String?
                                         },
                                         ?server_certificate_config: {
                                           enable_ocsp_check: bool?,
                                           ocsp_lambda_arn: ::String?,
                                           ocsp_authorized_responder_arn: ::String?
                                         },
                                         ?authentication_type: ("CUSTOM_AUTH_X509" | "CUSTOM_AUTH" | "AWS_X509" | "AWS_SIGV4" | "DEFAULT"),
                                         ?application_protocol: ("SECURE_MQTT" | "MQTT_WSS" | "HTTPS" | "DEFAULT"),
                                         ?client_certificate_config: {
                                           client_certificate_callback_arn: ::String?
                                         }
                                       ) -> _UpdateDomainConfigurationResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDomainConfigurationResponseSuccess

      interface _UpdateDynamicThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDynamicThingGroupResponse]
        def version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_dynamic_thing_group-instance_method
      def update_dynamic_thing_group: (
                                        thing_group_name: ::String,
                                        thing_group_properties: {
                                          thing_group_description: ::String?,
                                          attribute_payload: {
                                            attributes: Hash[::String, ::String]?,
                                            merge: bool?
                                          }?
                                        },
                                        ?expected_version: ::Integer,
                                        ?index_name: ::String,
                                        ?query_string: ::String,
                                        ?query_version: ::String
                                      ) -> _UpdateDynamicThingGroupResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDynamicThingGroupResponseSuccess

      interface _UpdateEventConfigurationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateEventConfigurationsResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_event_configurations-instance_method
      def update_event_configurations: (
                                         ?event_configurations: Hash[("THING" | "THING_GROUP" | "THING_TYPE" | "THING_GROUP_MEMBERSHIP" | "THING_GROUP_HIERARCHY" | "THING_TYPE_ASSOCIATION" | "JOB" | "JOB_EXECUTION" | "POLICY" | "CERTIFICATE" | "CA_CERTIFICATE"), {
                                             enabled: bool?
                                           }]
                                       ) -> _UpdateEventConfigurationsResponseSuccess
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateEventConfigurationsResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_fleet_metric-instance_method
      def update_fleet_metric: (
                                 metric_name: ::String,
                                 ?query_string: ::String,
                                 ?aggregation_type: {
                                   name: ("Statistics" | "Percentiles" | "Cardinality"),
                                   values: Array[::String]?
                                 },
                                 ?period: ::Integer,
                                 ?aggregation_field: ::String,
                                 ?description: ::String,
                                 ?query_version: ::String,
                                 index_name: ::String,
                                 ?unit: ("Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second" | "None"),
                                 ?expected_version: ::Integer
                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateIndexingConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateIndexingConfigurationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_indexing_configuration-instance_method
      def update_indexing_configuration: (
                                           ?thing_indexing_configuration: {
                                             thing_indexing_mode: ("OFF" | "REGISTRY" | "REGISTRY_AND_SHADOW"),
                                             thing_connectivity_indexing_mode: ("OFF" | "STATUS")?,
                                             device_defender_indexing_mode: ("OFF" | "VIOLATIONS")?,
                                             named_shadow_indexing_mode: ("OFF" | "ON")?,
                                             managed_fields: Array[
                                               {
                                                 name: ::String?,
                                                 type: ("Number" | "String" | "Boolean")?
                                               },
                                             ]?,
                                             custom_fields: Array[
                                               {
                                                 name: ::String?,
                                                 type: ("Number" | "String" | "Boolean")?
                                               },
                                             ]?,
                                             filter: {
                                               named_shadow_names: Array[::String]?,
                                               geo_locations: Array[
                                                 {
                                                   name: ::String?,
                                                   order: ("LatLon" | "LonLat")?
                                                 },
                                               ]?
                                             }?
                                           },
                                           ?thing_group_indexing_configuration: {
                                             thing_group_indexing_mode: ("OFF" | "ON"),
                                             managed_fields: Array[
                                               {
                                                 name: ::String?,
                                                 type: ("Number" | "String" | "Boolean")?
                                               },
                                             ]?,
                                             custom_fields: Array[
                                               {
                                                 name: ::String?,
                                                 type: ("Number" | "String" | "Boolean")?
                                               },
                                             ]?
                                           }
                                         ) -> _UpdateIndexingConfigurationResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateIndexingConfigurationResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_job-instance_method
      def update_job: (
                        job_id: ::String,
                        ?description: ::String,
                        ?presigned_url_config: {
                          role_arn: ::String?,
                          expires_in_sec: ::Integer?
                        },
                        ?job_executions_rollout_config: {
                          maximum_per_minute: ::Integer?,
                          exponential_rate: {
                            base_rate_per_minute: ::Integer,
                            increment_factor: ::Float,
                            rate_increase_criteria: {
                              number_of_notified_things: ::Integer?,
                              number_of_succeeded_things: ::Integer?
                            }
                          }?
                        },
                        ?abort_config: {
                          criteria_list: Array[
                            {
                              failure_type: ("FAILED" | "REJECTED" | "TIMED_OUT" | "ALL"),
                              action: ("CANCEL"),
                              threshold_percentage: ::Float,
                              min_number_of_executed_things: ::Integer
                            },
                          ]
                        },
                        ?timeout_config: {
                          in_progress_timeout_in_minutes: ::Integer?
                        },
                        ?namespace_id: ::String,
                        ?job_executions_retry_config: {
                          criteria_list: Array[
                            {
                              failure_type: ("FAILED" | "TIMED_OUT" | "ALL"),
                              number_of_retries: ::Integer
                            },
                          ]
                        }
                      ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _UpdateMitigationActionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateMitigationActionResponse]
        def action_arn: () -> ::String
        def action_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_mitigation_action-instance_method
      def update_mitigation_action: (
                                      action_name: ::String,
                                      ?role_arn: ::String,
                                      ?action_params: {
                                        update_device_certificate_params: {
                                          action: ("DEACTIVATE")
                                        }?,
                                        update_ca_certificate_params: {
                                          action: ("DEACTIVATE")
                                        }?,
                                        add_things_to_thing_group_params: {
                                          thing_group_names: Array[::String],
                                          override_dynamic_groups: bool?
                                        }?,
                                        replace_default_policy_version_params: {
                                          template_name: ("BLANK_POLICY")
                                        }?,
                                        enable_io_t_logging_params: {
                                          role_arn_for_logging: ::String,
                                          log_level: ("DEBUG" | "INFO" | "ERROR" | "WARN" | "DISABLED")
                                        }?,
                                        publish_finding_to_sns_params: {
                                          topic_arn: ::String
                                        }?
                                      }
                                    ) -> _UpdateMitigationActionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateMitigationActionResponseSuccess

      interface _UpdatePackageResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePackageResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_package-instance_method
      def update_package: (
                            package_name: ::String,
                            ?description: ::String,
                            ?default_version_name: ::String,
                            ?unset_default_version: bool,
                            ?client_token: ::String
                          ) -> _UpdatePackageResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePackageResponseSuccess

      interface _UpdatePackageConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePackageConfigurationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_package_configuration-instance_method
      def update_package_configuration: (
                                          ?version_update_by_jobs_config: {
                                            enabled: bool?,
                                            role_arn: ::String?
                                          },
                                          ?client_token: ::String
                                        ) -> _UpdatePackageConfigurationResponseSuccess
                                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePackageConfigurationResponseSuccess

      interface _UpdatePackageVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePackageVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_package_version-instance_method
      def update_package_version: (
                                    package_name: ::String,
                                    version_name: ::String,
                                    ?description: ::String,
                                    ?attributes: Hash[::String, ::String],
                                    ?artifact: {
                                      s3_location: {
                                        bucket: ::String?,
                                        key: ::String?,
                                        version: ::String?
                                      }?
                                    },
                                    ?action: ("PUBLISH" | "DEPRECATE"),
                                    ?recipe: ::String,
                                    ?client_token: ::String
                                  ) -> _UpdatePackageVersionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePackageVersionResponseSuccess

      interface _UpdateProvisioningTemplateResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateProvisioningTemplateResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_provisioning_template-instance_method
      def update_provisioning_template: (
                                          template_name: ::String,
                                          ?description: ::String,
                                          ?enabled: bool,
                                          ?default_version_id: ::Integer,
                                          ?provisioning_role_arn: ::String,
                                          ?pre_provisioning_hook: {
                                            payload_version: ::String?,
                                            target_arn: ::String
                                          },
                                          ?remove_pre_provisioning_hook: bool
                                        ) -> _UpdateProvisioningTemplateResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateProvisioningTemplateResponseSuccess

      interface _UpdateRoleAliasResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateRoleAliasResponse]
        def role_alias: () -> ::String
        def role_alias_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_role_alias-instance_method
      def update_role_alias: (
                               role_alias: ::String,
                               ?role_arn: ::String,
                               ?credential_duration_seconds: ::Integer
                             ) -> _UpdateRoleAliasResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateRoleAliasResponseSuccess

      interface _UpdateScheduledAuditResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateScheduledAuditResponse]
        def scheduled_audit_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_scheduled_audit-instance_method
      def update_scheduled_audit: (
                                    ?frequency: ("DAILY" | "WEEKLY" | "BIWEEKLY" | "MONTHLY"),
                                    ?day_of_month: ::String,
                                    ?day_of_week: ("SUN" | "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT"),
                                    ?target_check_names: Array[::String],
                                    scheduled_audit_name: ::String
                                  ) -> _UpdateScheduledAuditResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateScheduledAuditResponseSuccess

      interface _UpdateSecurityProfileResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateSecurityProfileResponse]
        def security_profile_name: () -> ::String
        def security_profile_arn: () -> ::String
        def security_profile_description: () -> ::String
        def behaviors: () -> ::Array[Types::Behavior]
        def alert_targets: () -> ::Hash[("SNS"), Types::AlertTarget]
        def additional_metrics_to_retain: () -> ::Array[::String]
        def additional_metrics_to_retain_v2: () -> ::Array[Types::MetricToRetain]
        def version: () -> ::Integer
        def creation_date: () -> ::Time
        def last_modified_date: () -> ::Time
        def metrics_export_config: () -> Types::MetricsExportConfig
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_security_profile-instance_method
      def update_security_profile: (
                                     security_profile_name: ::String,
                                     ?security_profile_description: ::String,
                                     ?behaviors: Array[
                                       {
                                         name: ::String,
                                         metric: ::String?,
                                         metric_dimension: {
                                           dimension_name: ::String,
                                           operator: ("IN" | "NOT_IN")?
                                         }?,
                                         criteria: {
                                           comparison_operator: ("less-than" | "less-than-equals" | "greater-than" | "greater-than-equals" | "in-cidr-set" | "not-in-cidr-set" | "in-port-set" | "not-in-port-set" | "in-set" | "not-in-set")?,
                                           value: {
                                             count: ::Integer?,
                                             cidrs: Array[::String]?,
                                             ports: Array[::Integer]?,
                                             number: ::Float?,
                                             numbers: Array[::Float]?,
                                             strings: Array[::String]?
                                           }?,
                                           duration_seconds: ::Integer?,
                                           consecutive_datapoints_to_alarm: ::Integer?,
                                           consecutive_datapoints_to_clear: ::Integer?,
                                           statistical_threshold: {
                                             statistic: ::String?
                                           }?,
                                           ml_detection_config: {
                                             confidence_level: ("LOW" | "MEDIUM" | "HIGH")
                                           }?
                                         }?,
                                         suppress_alerts: bool?,
                                         export_metric: bool?
                                       },
                                     ],
                                     ?alert_targets: Hash[("SNS"), {
                                         alert_target_arn: ::String,
                                         role_arn: ::String
                                       }],
                                     ?additional_metrics_to_retain: Array[::String],
                                     ?additional_metrics_to_retain_v2: Array[
                                       {
                                         metric: ::String,
                                         metric_dimension: {
                                           dimension_name: ::String,
                                           operator: ("IN" | "NOT_IN")?
                                         }?,
                                         export_metric: bool?
                                       },
                                     ],
                                     ?delete_behaviors: bool,
                                     ?delete_alert_targets: bool,
                                     ?delete_additional_metrics_to_retain: bool,
                                     ?expected_version: ::Integer,
                                     ?metrics_export_config: {
                                       mqtt_topic: ::String,
                                       role_arn: ::String
                                     },
                                     ?delete_metrics_export_config: bool
                                   ) -> _UpdateSecurityProfileResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateSecurityProfileResponseSuccess

      interface _UpdateStreamResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateStreamResponse]
        def stream_id: () -> ::String
        def stream_arn: () -> ::String
        def description: () -> ::String
        def stream_version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_stream-instance_method
      def update_stream: (
                           stream_id: ::String,
                           ?description: ::String,
                           ?files: Array[
                             {
                               file_id: ::Integer?,
                               s3_location: {
                                 bucket: ::String?,
                                 key: ::String?,
                                 version: ::String?
                               }?
                             },
                           ],
                           ?role_arn: ::String
                         ) -> _UpdateStreamResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateStreamResponseSuccess

      interface _UpdateThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateThingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_thing-instance_method
      def update_thing: (
                          thing_name: ::String,
                          ?thing_type_name: ::String,
                          ?attribute_payload: {
                            attributes: Hash[::String, ::String]?,
                            merge: bool?
                          },
                          ?expected_version: ::Integer,
                          ?remove_thing_type: bool
                        ) -> _UpdateThingResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateThingResponseSuccess

      interface _UpdateThingGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateThingGroupResponse]
        def version: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_thing_group-instance_method
      def update_thing_group: (
                                thing_group_name: ::String,
                                thing_group_properties: {
                                  thing_group_description: ::String?,
                                  attribute_payload: {
                                    attributes: Hash[::String, ::String]?,
                                    merge: bool?
                                  }?
                                },
                                ?expected_version: ::Integer
                              ) -> _UpdateThingGroupResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateThingGroupResponseSuccess

      interface _UpdateThingGroupsForThingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateThingGroupsForThingResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_thing_groups_for_thing-instance_method
      def update_thing_groups_for_thing: (
                                           ?thing_name: ::String,
                                           ?thing_groups_to_add: Array[::String],
                                           ?thing_groups_to_remove: Array[::String],
                                           ?override_dynamic_groups: bool
                                         ) -> _UpdateThingGroupsForThingResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateThingGroupsForThingResponseSuccess

      interface _UpdateThingTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateThingTypeResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_thing_type-instance_method
      def update_thing_type: (
                               thing_type_name: ::String,
                               ?thing_type_properties: {
                                 thing_type_description: ::String?,
                                 searchable_attributes: Array[::String]?,
                                 mqtt5_configuration: {
                                   propagating_attributes: Array[
                                     {
                                       user_property_key: ::String?,
                                       thing_attribute: ::String?,
                                       connection_attribute: ::String?
                                     },
                                   ]?
                                 }?
                               }
                             ) -> _UpdateThingTypeResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateThingTypeResponseSuccess

      interface _UpdateTopicRuleDestinationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTopicRuleDestinationResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#update_topic_rule_destination-instance_method
      def update_topic_rule_destination: (
                                           arn: ::String,
                                           status: ("ENABLED" | "IN_PROGRESS" | "DISABLED" | "ERROR" | "DELETING")
                                         ) -> _UpdateTopicRuleDestinationResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTopicRuleDestinationResponseSuccess

      interface _ValidateSecurityProfileBehaviorsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ValidateSecurityProfileBehaviorsResponse]
        def valid: () -> bool
        def validation_errors: () -> ::Array[Types::ValidationError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/IoT/Client.html#validate_security_profile_behaviors-instance_method
      def validate_security_profile_behaviors: (
                                                 behaviors: Array[
                                                   {
                                                     name: ::String,
                                                     metric: ::String?,
                                                     metric_dimension: {
                                                       dimension_name: ::String,
                                                       operator: ("IN" | "NOT_IN")?
                                                     }?,
                                                     criteria: {
                                                       comparison_operator: ("less-than" | "less-than-equals" | "greater-than" | "greater-than-equals" | "in-cidr-set" | "not-in-cidr-set" | "in-port-set" | "not-in-port-set" | "in-set" | "not-in-set")?,
                                                       value: {
                                                         count: ::Integer?,
                                                         cidrs: Array[::String]?,
                                                         ports: Array[::Integer]?,
                                                         number: ::Float?,
                                                         numbers: Array[::Float]?,
                                                         strings: Array[::String]?
                                                       }?,
                                                       duration_seconds: ::Integer?,
                                                       consecutive_datapoints_to_alarm: ::Integer?,
                                                       consecutive_datapoints_to_clear: ::Integer?,
                                                       statistical_threshold: {
                                                         statistic: ::String?
                                                       }?,
                                                       ml_detection_config: {
                                                         confidence_level: ("LOW" | "MEDIUM" | "HIGH")
                                                       }?
                                                     }?,
                                                     suppress_alerts: bool?,
                                                     export_metric: bool?
                                                   },
                                                 ]
                                               ) -> _ValidateSecurityProfileBehaviorsResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ValidateSecurityProfileBehaviorsResponseSuccess
    end
  end
end