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

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#initialize-instance_method
      def self.new: (
                      ?credentials: untyped,
                      ?region: String,
                      ?access_key_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,
                      ?simple_json: bool,
                      ?stub_responses: untyped,
                      ?token_provider: untyped,
                      ?use_dualstack_endpoint: bool,
                      ?use_fips_endpoint: bool,
                      ?validate_params: bool,
                      ?endpoint_provider: untyped,
                      ?http_proxy: String,
                      ?http_open_timeout: (Float | Integer),
                      ?http_read_timeout: (Float | Integer),
                      ?http_idle_timeout: (Float | Integer),
                      ?http_continue_timeout: (Float | Integer),
                      ?ssl_timeout: (Float | Integer | nil),
                      ?http_wire_trace: bool,
                      ?ssl_verify_peer: bool,
                      ?ssl_ca_bundle: String,
                      ?ssl_ca_directory: String,
                      ?ssl_ca_store: String,
                      ?on_chunk_received: Proc,
                      ?on_chunk_sent: Proc,
                      ?raise_response_errors: bool
                    ) -> instance
                  | (?Hash[Symbol, untyped]) -> instance


      interface _BatchCreatePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchCreatePartitionResponse]
        def errors: () -> ::Array[Types::PartitionError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_create_partition-instance_method
      def batch_create_partition: (
                                    ?catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    partition_input_list: Array[
                                      {
                                        values: Array[::String]?,
                                        last_access_time: ::Time?,
                                        storage_descriptor: {
                                          columns: Array[
                                            {
                                              name: ::String,
                                              type: ::String?,
                                              comment: ::String?,
                                              parameters: Hash[::String, ::String]?
                                            },
                                          ]?,
                                          location: ::String?,
                                          additional_locations: Array[::String]?,
                                          input_format: ::String?,
                                          output_format: ::String?,
                                          compressed: bool?,
                                          number_of_buckets: ::Integer?,
                                          serde_info: {
                                            name: ::String?,
                                            serialization_library: ::String?,
                                            parameters: Hash[::String, ::String]?
                                          }?,
                                          bucket_columns: Array[::String]?,
                                          sort_columns: Array[
                                            {
                                              column: ::String,
                                              sort_order: ::Integer
                                            },
                                          ]?,
                                          parameters: Hash[::String, ::String]?,
                                          skewed_info: {
                                            skewed_column_names: Array[::String]?,
                                            skewed_column_values: Array[::String]?,
                                            skewed_column_value_location_maps: Hash[::String, ::String]?
                                          }?,
                                          stored_as_sub_directories: bool?,
                                          schema_reference: {
                                            schema_id: {
                                              schema_arn: ::String?,
                                              schema_name: ::String?,
                                              registry_name: ::String?
                                            }?,
                                            schema_version_id: ::String?,
                                            schema_version_number: ::Integer?
                                          }?
                                        }?,
                                        parameters: Hash[::String, ::String]?,
                                        last_analyzed_time: ::Time?
                                      },
                                    ]
                                  ) -> _BatchCreatePartitionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchCreatePartitionResponseSuccess

      interface _BatchDeleteConnectionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchDeleteConnectionResponse]
        def succeeded: () -> ::Array[::String]
        def errors: () -> ::Hash[::String, Types::ErrorDetail]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_delete_connection-instance_method
      def batch_delete_connection: (
                                     ?catalog_id: ::String,
                                     connection_name_list: Array[::String]
                                   ) -> _BatchDeleteConnectionResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchDeleteConnectionResponseSuccess

      interface _BatchDeletePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchDeletePartitionResponse]
        def errors: () -> ::Array[Types::PartitionError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_delete_partition-instance_method
      def batch_delete_partition: (
                                    ?catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    partitions_to_delete: Array[
                                      {
                                        values: Array[::String]
                                      },
                                    ]
                                  ) -> _BatchDeletePartitionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchDeletePartitionResponseSuccess

      interface _BatchDeleteTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchDeleteTableResponse]
        def errors: () -> ::Array[Types::TableError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_delete_table-instance_method
      def batch_delete_table: (
                                ?catalog_id: ::String,
                                database_name: ::String,
                                tables_to_delete: Array[::String],
                                ?transaction_id: ::String
                              ) -> _BatchDeleteTableResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchDeleteTableResponseSuccess

      interface _BatchDeleteTableVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchDeleteTableVersionResponse]
        def errors: () -> ::Array[Types::TableVersionError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_delete_table_version-instance_method
      def batch_delete_table_version: (
                                        ?catalog_id: ::String,
                                        database_name: ::String,
                                        table_name: ::String,
                                        version_ids: Array[::String]
                                      ) -> _BatchDeleteTableVersionResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchDeleteTableVersionResponseSuccess

      interface _BatchGetBlueprintsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetBlueprintsResponse]
        def blueprints: () -> ::Array[Types::Blueprint]
        def missing_blueprints: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_blueprints-instance_method
      def batch_get_blueprints: (
                                  names: Array[::String],
                                  ?include_blueprint: bool,
                                  ?include_parameter_spec: bool
                                ) -> _BatchGetBlueprintsResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetBlueprintsResponseSuccess

      interface _BatchGetCrawlersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetCrawlersResponse]
        def crawlers: () -> ::Array[Types::Crawler]
        def crawlers_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_crawlers-instance_method
      def batch_get_crawlers: (
                                crawler_names: Array[::String]
                              ) -> _BatchGetCrawlersResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetCrawlersResponseSuccess

      interface _BatchGetCustomEntityTypesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetCustomEntityTypesResponse]
        def custom_entity_types: () -> ::Array[Types::CustomEntityType]
        def custom_entity_types_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_custom_entity_types-instance_method
      def batch_get_custom_entity_types: (
                                           names: Array[::String]
                                         ) -> _BatchGetCustomEntityTypesResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetCustomEntityTypesResponseSuccess

      interface _BatchGetDataQualityResultResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetDataQualityResultResponse]
        def results: () -> ::Array[Types::DataQualityResult]
        def results_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_data_quality_result-instance_method
      def batch_get_data_quality_result: (
                                           result_ids: Array[::String]
                                         ) -> _BatchGetDataQualityResultResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetDataQualityResultResponseSuccess

      interface _BatchGetDevEndpointsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetDevEndpointsResponse]
        def dev_endpoints: () -> ::Array[Types::DevEndpoint]
        def dev_endpoints_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_dev_endpoints-instance_method
      def batch_get_dev_endpoints: (
                                     dev_endpoint_names: Array[::String]
                                   ) -> _BatchGetDevEndpointsResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetDevEndpointsResponseSuccess

      interface _BatchGetJobsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetJobsResponse]
        def jobs: () -> ::Array[Types::Job]
        def jobs_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_jobs-instance_method
      def batch_get_jobs: (
                            job_names: Array[::String]
                          ) -> _BatchGetJobsResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetJobsResponseSuccess

      interface _BatchGetPartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetPartitionResponse]
        def partitions: () -> ::Array[Types::Partition]
        def unprocessed_keys: () -> ::Array[Types::PartitionValueList]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_partition-instance_method
      def batch_get_partition: (
                                 ?catalog_id: ::String,
                                 database_name: ::String,
                                 table_name: ::String,
                                 partitions_to_get: Array[
                                   {
                                     values: Array[::String]
                                   },
                                 ]
                               ) -> _BatchGetPartitionResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetPartitionResponseSuccess

      interface _BatchGetTableOptimizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetTableOptimizerResponse]
        def table_optimizers: () -> ::Array[Types::BatchTableOptimizer]
        def failures: () -> ::Array[Types::BatchGetTableOptimizerError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_table_optimizer-instance_method
      def batch_get_table_optimizer: (
                                       entries: Array[
                                         {
                                           catalog_id: ::String?,
                                           database_name: ::String?,
                                           table_name: ::String?,
                                           type: ("compaction")?
                                         },
                                       ]
                                     ) -> _BatchGetTableOptimizerResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetTableOptimizerResponseSuccess

      interface _BatchGetTriggersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetTriggersResponse]
        def triggers: () -> ::Array[Types::Trigger]
        def triggers_not_found: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_triggers-instance_method
      def batch_get_triggers: (
                                trigger_names: Array[::String]
                              ) -> _BatchGetTriggersResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetTriggersResponseSuccess

      interface _BatchGetWorkflowsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetWorkflowsResponse]
        def workflows: () -> ::Array[Types::Workflow]
        def missing_workflows: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_get_workflows-instance_method
      def batch_get_workflows: (
                                 names: Array[::String],
                                 ?include_graph: bool
                               ) -> _BatchGetWorkflowsResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetWorkflowsResponseSuccess

      interface _BatchStopJobRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchStopJobRunResponse]
        def successful_submissions: () -> ::Array[Types::BatchStopJobRunSuccessfulSubmission]
        def errors: () -> ::Array[Types::BatchStopJobRunError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_stop_job_run-instance_method
      def batch_stop_job_run: (
                                job_name: ::String,
                                job_run_ids: Array[::String]
                              ) -> _BatchStopJobRunResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchStopJobRunResponseSuccess

      interface _BatchUpdatePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::BatchUpdatePartitionResponse]
        def errors: () -> ::Array[Types::BatchUpdatePartitionFailureEntry]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#batch_update_partition-instance_method
      def batch_update_partition: (
                                    ?catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    entries: Array[
                                      {
                                        partition_value_list: Array[::String],
                                        partition_input: {
                                          values: Array[::String]?,
                                          last_access_time: ::Time?,
                                          storage_descriptor: {
                                            columns: Array[
                                              {
                                                name: ::String,
                                                type: ::String?,
                                                comment: ::String?,
                                                parameters: Hash[::String, ::String]?
                                              },
                                            ]?,
                                            location: ::String?,
                                            additional_locations: Array[::String]?,
                                            input_format: ::String?,
                                            output_format: ::String?,
                                            compressed: bool?,
                                            number_of_buckets: ::Integer?,
                                            serde_info: {
                                              name: ::String?,
                                              serialization_library: ::String?,
                                              parameters: Hash[::String, ::String]?
                                            }?,
                                            bucket_columns: Array[::String]?,
                                            sort_columns: Array[
                                              {
                                                column: ::String,
                                                sort_order: ::Integer
                                              },
                                            ]?,
                                            parameters: Hash[::String, ::String]?,
                                            skewed_info: {
                                              skewed_column_names: Array[::String]?,
                                              skewed_column_values: Array[::String]?,
                                              skewed_column_value_location_maps: Hash[::String, ::String]?
                                            }?,
                                            stored_as_sub_directories: bool?,
                                            schema_reference: {
                                              schema_id: {
                                                schema_arn: ::String?,
                                                schema_name: ::String?,
                                                registry_name: ::String?
                                              }?,
                                              schema_version_id: ::String?,
                                              schema_version_number: ::Integer?
                                            }?
                                          }?,
                                          parameters: Hash[::String, ::String]?,
                                          last_analyzed_time: ::Time?
                                        }
                                      },
                                    ]
                                  ) -> _BatchUpdatePartitionResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchUpdatePartitionResponseSuccess

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

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

      interface _CancelMLTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CancelMLTaskRunResponse]
        def transform_id: () -> ::String
        def task_run_id: () -> ::String
        def status: () -> ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#cancel_ml_task_run-instance_method
      def cancel_ml_task_run: (
                                transform_id: ::String,
                                task_run_id: ::String
                              ) -> _CancelMLTaskRunResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CancelMLTaskRunResponseSuccess

      interface _CancelStatementResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CancelStatementResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#cancel_statement-instance_method
      def cancel_statement: (
                              session_id: ::String,
                              id: ::Integer,
                              ?request_origin: ::String
                            ) -> _CancelStatementResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CancelStatementResponseSuccess

      interface _CheckSchemaVersionValidityResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CheckSchemaVersionValidityResponse]
        def valid: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#check_schema_version_validity-instance_method
      def check_schema_version_validity: (
                                           data_format: ("AVRO" | "JSON" | "PROTOBUF"),
                                           schema_definition: ::String
                                         ) -> _CheckSchemaVersionValidityResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CheckSchemaVersionValidityResponseSuccess

      interface _CreateBlueprintResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateBlueprintResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_blueprint-instance_method
      def create_blueprint: (
                              name: ::String,
                              ?description: ::String,
                              blueprint_location: ::String,
                              ?tags: Hash[::String, ::String]
                            ) -> _CreateBlueprintResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateBlueprintResponseSuccess

      interface _CreateClassifierResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateClassifierResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_classifier-instance_method
      def create_classifier: (
                               ?grok_classifier: {
                                 classification: ::String,
                                 name: ::String,
                                 grok_pattern: ::String,
                                 custom_patterns: ::String?
                               },
                               ?xml_classifier: {
                                 classification: ::String,
                                 name: ::String,
                                 row_tag: ::String?
                               },
                               ?json_classifier: {
                                 name: ::String,
                                 json_path: ::String
                               },
                               ?csv_classifier: {
                                 name: ::String,
                                 delimiter: ::String?,
                                 quote_symbol: ::String?,
                                 contains_header: ("UNKNOWN" | "PRESENT" | "ABSENT")?,
                                 header: Array[::String]?,
                                 disable_value_trimming: bool?,
                                 allow_single_column: bool?,
                                 custom_datatype_configured: bool?,
                                 custom_datatypes: Array[::String]?,
                                 serde: ("OpenCSVSerDe" | "LazySimpleSerDe" | "None")?
                               }
                             ) -> _CreateClassifierResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateClassifierResponseSuccess

      interface _CreateConnectionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateConnectionResponse]
        def create_connection_status: () -> ("READY" | "IN_PROGRESS" | "FAILED")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_connection-instance_method
      def create_connection: (
                               ?catalog_id: ::String,
                               connection_input: {
                                 name: ::String,
                                 description: ::String?,
                                 connection_type: ("JDBC" | "SFTP" | "MONGODB" | "KAFKA" | "NETWORK" | "MARKETPLACE" | "CUSTOM" | "SALESFORCE"),
                                 match_criteria: Array[::String]?,
                                 connection_properties: Hash[("HOST" | "PORT" | "USERNAME" | "PASSWORD" | "ENCRYPTED_PASSWORD" | "JDBC_DRIVER_JAR_URI" | "JDBC_DRIVER_CLASS_NAME" | "JDBC_ENGINE" | "JDBC_ENGINE_VERSION" | "CONFIG_FILES" | "INSTANCE_ID" | "JDBC_CONNECTION_URL" | "JDBC_ENFORCE_SSL" | "CUSTOM_JDBC_CERT" | "SKIP_CUSTOM_JDBC_CERT_VALIDATION" | "CUSTOM_JDBC_CERT_STRING" | "CONNECTION_URL" | "KAFKA_BOOTSTRAP_SERVERS" | "KAFKA_SSL_ENABLED" | "KAFKA_CUSTOM_CERT" | "KAFKA_SKIP_CUSTOM_CERT_VALIDATION" | "KAFKA_CLIENT_KEYSTORE" | "KAFKA_CLIENT_KEYSTORE_PASSWORD" | "KAFKA_CLIENT_KEY_PASSWORD" | "ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD" | "ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD" | "SECRET_ID" | "CONNECTOR_URL" | "CONNECTOR_TYPE" | "CONNECTOR_CLASS_NAME" | "KAFKA_SASL_MECHANISM" | "KAFKA_SASL_PLAIN_USERNAME" | "KAFKA_SASL_PLAIN_PASSWORD" | "ENCRYPTED_KAFKA_SASL_PLAIN_PASSWORD" | "KAFKA_SASL_SCRAM_USERNAME" | "KAFKA_SASL_SCRAM_PASSWORD" | "KAFKA_SASL_SCRAM_SECRETS_ARN" | "ENCRYPTED_KAFKA_SASL_SCRAM_PASSWORD" | "KAFKA_SASL_GSSAPI_KEYTAB" | "KAFKA_SASL_GSSAPI_KRB5_CONF" | "KAFKA_SASL_GSSAPI_SERVICE" | "KAFKA_SASL_GSSAPI_PRINCIPAL" | "ROLE_ARN"), ::String],
                                 physical_connection_requirements: {
                                   subnet_id: ::String?,
                                   security_group_id_list: Array[::String]?,
                                   availability_zone: ::String?
                                 }?,
                                 authentication_configuration: {
                                   authentication_type: ("BASIC" | "OAUTH2" | "CUSTOM")?,
                                   secret_arn: ::String?,
                                   o_auth_2_properties: {
                                     o_auth_2_grant_type: ("AUTHORIZATION_CODE" | "CLIENT_CREDENTIALS" | "JWT_BEARER")?,
                                     o_auth_2_client_application: {
                                       user_managed_client_application_client_id: ::String?,
                                       aws_managed_client_application_reference: ::String?
                                     }?,
                                     token_url: ::String?,
                                     token_url_parameters_map: Hash[::String, ::String]?,
                                     authorization_code_properties: {
                                       authorization_code: ::String?,
                                       redirect_uri: ::String?
                                     }?
                                   }?
                                 }?,
                                 validate_credentials: bool?
                               },
                               ?tags: Hash[::String, ::String]
                             ) -> _CreateConnectionResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateConnectionResponseSuccess

      interface _CreateCrawlerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCrawlerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_crawler-instance_method
      def create_crawler: (
                            name: ::String,
                            role: ::String,
                            ?database_name: ::String,
                            ?description: ::String,
                            targets: {
                              s3_targets: Array[
                                {
                                  path: ::String?,
                                  exclusions: Array[::String]?,
                                  connection_name: ::String?,
                                  sample_size: ::Integer?,
                                  event_queue_arn: ::String?,
                                  dlq_event_queue_arn: ::String?
                                },
                              ]?,
                              jdbc_targets: Array[
                                {
                                  connection_name: ::String?,
                                  path: ::String?,
                                  exclusions: Array[::String]?,
                                  enable_additional_metadata: Array[("COMMENTS" | "RAWTYPES")]?
                                },
                              ]?,
                              mongo_db_targets: Array[
                                {
                                  connection_name: ::String?,
                                  path: ::String?,
                                  scan_all: bool?
                                },
                              ]?,
                              dynamo_db_targets: Array[
                                {
                                  path: ::String?,
                                  scan_all: bool?,
                                  scan_rate: ::Float?
                                },
                              ]?,
                              catalog_targets: Array[
                                {
                                  database_name: ::String,
                                  tables: Array[::String],
                                  connection_name: ::String?,
                                  event_queue_arn: ::String?,
                                  dlq_event_queue_arn: ::String?
                                },
                              ]?,
                              delta_targets: Array[
                                {
                                  delta_tables: Array[::String]?,
                                  connection_name: ::String?,
                                  write_manifest: bool?,
                                  create_native_delta_table: bool?
                                },
                              ]?,
                              iceberg_targets: Array[
                                {
                                  paths: Array[::String]?,
                                  connection_name: ::String?,
                                  exclusions: Array[::String]?,
                                  maximum_traversal_depth: ::Integer?
                                },
                              ]?,
                              hudi_targets: Array[
                                {
                                  paths: Array[::String]?,
                                  connection_name: ::String?,
                                  exclusions: Array[::String]?,
                                  maximum_traversal_depth: ::Integer?
                                },
                              ]?
                            },
                            ?schedule: ::String,
                            ?classifiers: Array[::String],
                            ?table_prefix: ::String,
                            ?schema_change_policy: {
                              update_behavior: ("LOG" | "UPDATE_IN_DATABASE")?,
                              delete_behavior: ("LOG" | "DELETE_FROM_DATABASE" | "DEPRECATE_IN_DATABASE")?
                            },
                            ?recrawl_policy: {
                              recrawl_behavior: ("CRAWL_EVERYTHING" | "CRAWL_NEW_FOLDERS_ONLY" | "CRAWL_EVENT_MODE")?
                            },
                            ?lineage_configuration: {
                              crawler_lineage_settings: ("ENABLE" | "DISABLE")?
                            },
                            ?lake_formation_configuration: {
                              use_lake_formation_credentials: bool?,
                              account_id: ::String?
                            },
                            ?configuration: ::String,
                            ?crawler_security_configuration: ::String,
                            ?tags: Hash[::String, ::String]
                          ) -> _CreateCrawlerResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCrawlerResponseSuccess

      interface _CreateCustomEntityTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCustomEntityTypeResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_custom_entity_type-instance_method
      def create_custom_entity_type: (
                                       name: ::String,
                                       regex_string: ::String,
                                       ?context_words: Array[::String],
                                       ?tags: Hash[::String, ::String]
                                     ) -> _CreateCustomEntityTypeResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCustomEntityTypeResponseSuccess

      interface _CreateDataQualityRulesetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDataQualityRulesetResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_data_quality_ruleset-instance_method
      def create_data_quality_ruleset: (
                                         name: ::String,
                                         ?description: ::String,
                                         ruleset: ::String,
                                         ?tags: Hash[::String, ::String],
                                         ?target_table: {
                                           table_name: ::String,
                                           database_name: ::String,
                                           catalog_id: ::String?
                                         },
                                         ?client_token: ::String
                                       ) -> _CreateDataQualityRulesetResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDataQualityRulesetResponseSuccess

      interface _CreateDatabaseResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDatabaseResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_database-instance_method
      def create_database: (
                             ?catalog_id: ::String,
                             database_input: {
                               name: ::String,
                               description: ::String?,
                               location_uri: ::String?,
                               parameters: Hash[::String, ::String]?,
                               create_table_default_permissions: Array[
                                 {
                                   principal: {
                                     data_lake_principal_identifier: ::String?
                                   }?,
                                   permissions: Array[("ALL" | "SELECT" | "ALTER" | "DROP" | "DELETE" | "INSERT" | "CREATE_DATABASE" | "CREATE_TABLE" | "DATA_LOCATION_ACCESS")]?
                                 },
                               ]?,
                               target_database: {
                                 catalog_id: ::String?,
                                 database_name: ::String?,
                                 region: ::String?
                               }?,
                               federated_database: {
                                 identifier: ::String?,
                                 connection_name: ::String?
                               }?
                             },
                             ?tags: Hash[::String, ::String]
                           ) -> _CreateDatabaseResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDatabaseResponseSuccess

      interface _CreateDevEndpointResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDevEndpointResponse]
        def endpoint_name: () -> ::String
        def status: () -> ::String
        def security_group_ids: () -> ::Array[::String]
        def subnet_id: () -> ::String
        def role_arn: () -> ::String
        def yarn_endpoint_address: () -> ::String
        def zeppelin_remote_spark_interpreter_port: () -> ::Integer
        def number_of_nodes: () -> ::Integer
        def worker_type: () -> ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X")
        def glue_version: () -> ::String
        def number_of_workers: () -> ::Integer
        def availability_zone: () -> ::String
        def vpc_id: () -> ::String
        def extra_python_libs_s3_path: () -> ::String
        def extra_jars_s3_path: () -> ::String
        def failure_reason: () -> ::String
        def security_configuration: () -> ::String
        def created_timestamp: () -> ::Time
        def arguments: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_dev_endpoint-instance_method
      def create_dev_endpoint: (
                                 endpoint_name: ::String,
                                 role_arn: ::String,
                                 ?security_group_ids: Array[::String],
                                 ?subnet_id: ::String,
                                 ?public_key: ::String,
                                 ?public_keys: Array[::String],
                                 ?number_of_nodes: ::Integer,
                                 ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                                 ?glue_version: ::String,
                                 ?number_of_workers: ::Integer,
                                 ?extra_python_libs_s3_path: ::String,
                                 ?extra_jars_s3_path: ::String,
                                 ?security_configuration: ::String,
                                 ?tags: Hash[::String, ::String],
                                 ?arguments: Hash[::String, ::String]
                               ) -> _CreateDevEndpointResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDevEndpointResponseSuccess

      interface _CreateJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateJobResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_job-instance_method
      def create_job: (
                        name: ::String,
                        ?job_mode: ("SCRIPT" | "VISUAL" | "NOTEBOOK"),
                        ?description: ::String,
                        ?log_uri: ::String,
                        role: ::String,
                        ?execution_property: {
                          max_concurrent_runs: ::Integer?
                        },
                        command: {
                          name: ::String?,
                          script_location: ::String?,
                          python_version: ::String?,
                          runtime: ::String?
                        },
                        ?default_arguments: Hash[::String, ::String],
                        ?non_overridable_arguments: Hash[::String, ::String],
                        ?connections: {
                          connections: Array[::String]?
                        },
                        ?max_retries: ::Integer,
                        ?allocated_capacity: ::Integer,
                        ?timeout: ::Integer,
                        ?max_capacity: ::Float,
                        ?security_configuration: ::String,
                        ?tags: Hash[::String, ::String],
                        ?notification_property: {
                          notify_delay_after: ::Integer?
                        },
                        ?glue_version: ::String,
                        ?number_of_workers: ::Integer,
                        ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                        ?code_gen_configuration_nodes: Hash[::String, {
                            athena_connector_source: {
                              name: ::String,
                              connection_name: ::String,
                              connector_name: ::String,
                              connection_type: ::String,
                              connection_table: ::String?,
                              schema_name: ::String,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            jdbc_connector_source: {
                              name: ::String,
                              connection_name: ::String,
                              connector_name: ::String,
                              connection_type: ::String,
                              additional_options: {
                                filter_predicate: ::String?,
                                partition_column: ::String?,
                                lower_bound: ::Integer?,
                                upper_bound: ::Integer?,
                                num_partitions: ::Integer?,
                                job_bookmark_keys: Array[::String]?,
                                job_bookmark_keys_sort_order: ::String?,
                                data_type_mapping: Hash[("ARRAY" | "BIGINT" | "BINARY" | "BIT" | "BLOB" | "BOOLEAN" | "CHAR" | "CLOB" | "DATALINK" | "DATE" | "DECIMAL" | "DISTINCT" | "DOUBLE" | "FLOAT" | "INTEGER" | "JAVA_OBJECT" | "LONGNVARCHAR" | "LONGVARBINARY" | "LONGVARCHAR" | "NCHAR" | "NCLOB" | "NULL" | "NUMERIC" | "NVARCHAR" | "OTHER" | "REAL" | "REF" | "REF_CURSOR" | "ROWID" | "SMALLINT" | "SQLXML" | "STRUCT" | "TIME" | "TIME_WITH_TIMEZONE" | "TIMESTAMP" | "TIMESTAMP_WITH_TIMEZONE" | "TINYINT" | "VARBINARY" | "VARCHAR"), ("DATE" | "STRING" | "TIMESTAMP" | "INT" | "FLOAT" | "LONG" | "BIGDECIMAL" | "BYTE" | "SHORT" | "DOUBLE")]?
                              }?,
                              connection_table: ::String?,
                              query: ::String?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            spark_connector_source: {
                              name: ::String,
                              connection_name: ::String,
                              connector_name: ::String,
                              connection_type: ::String,
                              additional_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            redshift_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              redshift_tmp_dir: ::String?,
                              tmp_dir_iam_role: ::String?
                            }?,
                            s3_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              partition_predicate: ::String?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?
                              }?
                            }?,
                            s3_csv_source: {
                              name: ::String,
                              paths: Array[::String],
                              compression_type: ("gzip" | "bzip2")?,
                              exclusions: Array[::String]?,
                              group_size: ::String?,
                              group_files: ::String?,
                              recurse: bool?,
                              max_band: ::Integer?,
                              max_files_in_band: ::Integer?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?,
                                enable_sample_path: bool?,
                                sample_path: ::String?
                              }?,
                              separator: ("comma" | "ctrla" | "pipe" | "semicolon" | "tab"),
                              escaper: ::String?,
                              quote_char: ("quote" | "quillemet" | "single_quote" | "disabled"),
                              multiline: bool?,
                              with_header: bool?,
                              write_header: bool?,
                              skip_first: bool?,
                              optimize_performance: bool?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_json_source: {
                              name: ::String,
                              paths: Array[::String],
                              compression_type: ("gzip" | "bzip2")?,
                              exclusions: Array[::String]?,
                              group_size: ::String?,
                              group_files: ::String?,
                              recurse: bool?,
                              max_band: ::Integer?,
                              max_files_in_band: ::Integer?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?,
                                enable_sample_path: bool?,
                                sample_path: ::String?
                              }?,
                              json_path: ::String?,
                              multiline: bool?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_parquet_source: {
                              name: ::String,
                              paths: Array[::String],
                              compression_type: ("snappy" | "lzo" | "gzip" | "uncompressed" | "none")?,
                              exclusions: Array[::String]?,
                              group_size: ::String?,
                              group_files: ::String?,
                              recurse: bool?,
                              max_band: ::Integer?,
                              max_files_in_band: ::Integer?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?,
                                enable_sample_path: bool?,
                                sample_path: ::String?
                              }?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            relational_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            dynamo_db_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            jdbc_connector_target: {
                              name: ::String,
                              inputs: Array[::String],
                              connection_name: ::String,
                              connection_table: ::String,
                              connector_name: ::String,
                              connection_type: ::String,
                              additional_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            spark_connector_target: {
                              name: ::String,
                              inputs: Array[::String],
                              connection_name: ::String,
                              connector_name: ::String,
                              connection_type: ::String,
                              additional_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String
                            }?,
                            redshift_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String,
                              redshift_tmp_dir: ::String?,
                              tmp_dir_iam_role: ::String?,
                              upsert_redshift_options: {
                                table_location: ::String?,
                                connection_name: ::String?,
                                upsert_keys: Array[::String]?
                              }?
                            }?,
                            s3_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              table: ::String,
                              database: ::String,
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                              }?
                            }?,
                            s3_glue_parquet_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              path: ::String,
                              compression: ("snappy" | "lzo" | "gzip" | "uncompressed" | "none")?,
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                table: ::String?,
                                database: ::String?
                              }?
                            }?,
                            s3_direct_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              path: ::String,
                              compression: ::String?,
                              format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                table: ::String?,
                                database: ::String?
                              }?
                            }?,
                            apply_mapping: {
                              name: ::String,
                              inputs: Array[::String],
                              mapping: Array[
                                {
                                  to_key: ::String?,
                                  from_path: Array[::String]?,
                                  from_type: ::String?,
                                  to_type: ::String?,
                                  dropped: bool?,
                                  children: untyped?
                                },
                              ]
                            }?,
                            select_fields: {
                              name: ::String,
                              inputs: Array[::String],
                              paths: Array[
                                Array[::String],
                              ]
                            }?,
                            drop_fields: {
                              name: ::String,
                              inputs: Array[::String],
                              paths: Array[
                                Array[::String],
                              ]
                            }?,
                            rename_field: {
                              name: ::String,
                              inputs: Array[::String],
                              source_path: Array[::String],
                              target_path: Array[::String]
                            }?,
                            spigot: {
                              name: ::String,
                              inputs: Array[::String],
                              path: ::String,
                              topk: ::Integer?,
                              prob: ::Float?
                            }?,
                            join: {
                              name: ::String,
                              inputs: Array[::String],
                              join_type: ("equijoin" | "left" | "right" | "outer" | "leftsemi" | "leftanti"),
                              columns: Array[
                                {
                                  from: ::String,
                                  keys: Array[
                                    Array[::String],
                                  ]
                                },
                              ]
                            }?,
                            split_fields: {
                              name: ::String,
                              inputs: Array[::String],
                              paths: Array[
                                Array[::String],
                              ]
                            }?,
                            select_from_collection: {
                              name: ::String,
                              inputs: Array[::String],
                              index: ::Integer
                            }?,
                            fill_missing_values: {
                              name: ::String,
                              inputs: Array[::String],
                              imputed_path: ::String,
                              filled_path: ::String?
                            }?,
                            filter: {
                              name: ::String,
                              inputs: Array[::String],
                              logical_operator: ("AND" | "OR"),
                              filters: Array[
                                {
                                  operation: ("EQ" | "LT" | "GT" | "LTE" | "GTE" | "REGEX" | "ISNULL"),
                                  negated: bool?,
                                  values: Array[
                                    {
                                      type: ("COLUMNEXTRACTED" | "CONSTANT"),
                                      value: Array[::String]
                                    },
                                  ]
                                },
                              ]
                            }?,
                            custom_code: {
                              name: ::String,
                              inputs: Array[::String],
                              code: ::String,
                              class_name: ::String,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            spark_sql: {
                              name: ::String,
                              inputs: Array[::String],
                              sql_query: ::String,
                              sql_aliases: Array[
                                {
                                  from: ::String,
                                  alias: ::String
                                },
                              ],
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            direct_kinesis_source: {
                              name: ::String,
                              window_size: ::Integer?,
                              detect_schema: bool?,
                              streaming_options: {
                                endpoint_url: ::String?,
                                stream_name: ::String?,
                                classification: ::String?,
                                delimiter: ::String?,
                                starting_position: ("latest" | "trim_horizon" | "earliest" | "timestamp")?,
                                max_fetch_time_in_ms: ::Integer?,
                                max_fetch_records_per_shard: ::Integer?,
                                max_record_per_read: ::Integer?,
                                add_idle_time_between_reads: bool?,
                                idle_time_between_reads_in_ms: ::Integer?,
                                describe_shard_interval: ::Integer?,
                                num_retries: ::Integer?,
                                retry_interval_ms: ::Integer?,
                                max_retry_interval_ms: ::Integer?,
                                avoid_empty_batches: bool?,
                                stream_arn: ::String?,
                                role_arn: ::String?,
                                role_session_name: ::String?,
                                add_record_timestamp: ::String?,
                                emit_consumer_lag_metrics: ::String?,
                                starting_timestamp: ::Time?
                              }?,
                              data_preview_options: {
                                polling_time: ::Integer?,
                                record_polling_limit: ::Integer?
                              }?
                            }?,
                            direct_kafka_source: {
                              name: ::String,
                              streaming_options: {
                                bootstrap_servers: ::String?,
                                security_protocol: ::String?,
                                connection_name: ::String?,
                                topic_name: ::String?,
                                assign: ::String?,
                                subscribe_pattern: ::String?,
                                classification: ::String?,
                                delimiter: ::String?,
                                starting_offsets: ::String?,
                                ending_offsets: ::String?,
                                poll_timeout_ms: ::Integer?,
                                num_retries: ::Integer?,
                                retry_interval_ms: ::Integer?,
                                max_offsets_per_trigger: ::Integer?,
                                min_partitions: ::Integer?,
                                include_headers: bool?,
                                add_record_timestamp: ::String?,
                                emit_consumer_lag_metrics: ::String?,
                                starting_timestamp: ::Time?
                              }?,
                              window_size: ::Integer?,
                              detect_schema: bool?,
                              data_preview_options: {
                                polling_time: ::Integer?,
                                record_polling_limit: ::Integer?
                              }?
                            }?,
                            catalog_kinesis_source: {
                              name: ::String,
                              window_size: ::Integer?,
                              detect_schema: bool?,
                              table: ::String,
                              database: ::String,
                              streaming_options: {
                                endpoint_url: ::String?,
                                stream_name: ::String?,
                                classification: ::String?,
                                delimiter: ::String?,
                                starting_position: ("latest" | "trim_horizon" | "earliest" | "timestamp")?,
                                max_fetch_time_in_ms: ::Integer?,
                                max_fetch_records_per_shard: ::Integer?,
                                max_record_per_read: ::Integer?,
                                add_idle_time_between_reads: bool?,
                                idle_time_between_reads_in_ms: ::Integer?,
                                describe_shard_interval: ::Integer?,
                                num_retries: ::Integer?,
                                retry_interval_ms: ::Integer?,
                                max_retry_interval_ms: ::Integer?,
                                avoid_empty_batches: bool?,
                                stream_arn: ::String?,
                                role_arn: ::String?,
                                role_session_name: ::String?,
                                add_record_timestamp: ::String?,
                                emit_consumer_lag_metrics: ::String?,
                                starting_timestamp: ::Time?
                              }?,
                              data_preview_options: {
                                polling_time: ::Integer?,
                                record_polling_limit: ::Integer?
                              }?
                            }?,
                            catalog_kafka_source: {
                              name: ::String,
                              window_size: ::Integer?,
                              detect_schema: bool?,
                              table: ::String,
                              database: ::String,
                              streaming_options: {
                                bootstrap_servers: ::String?,
                                security_protocol: ::String?,
                                connection_name: ::String?,
                                topic_name: ::String?,
                                assign: ::String?,
                                subscribe_pattern: ::String?,
                                classification: ::String?,
                                delimiter: ::String?,
                                starting_offsets: ::String?,
                                ending_offsets: ::String?,
                                poll_timeout_ms: ::Integer?,
                                num_retries: ::Integer?,
                                retry_interval_ms: ::Integer?,
                                max_offsets_per_trigger: ::Integer?,
                                min_partitions: ::Integer?,
                                include_headers: bool?,
                                add_record_timestamp: ::String?,
                                emit_consumer_lag_metrics: ::String?,
                                starting_timestamp: ::Time?
                              }?,
                              data_preview_options: {
                                polling_time: ::Integer?,
                                record_polling_limit: ::Integer?
                              }?
                            }?,
                            drop_null_fields: {
                              name: ::String,
                              inputs: Array[::String],
                              null_check_box_list: {
                                is_empty: bool?,
                                is_null_string: bool?,
                                is_neg_one: bool?
                              }?,
                              null_text_list: Array[
                                {
                                  value: ::String,
                                  datatype: {
                                    id: ::String,
                                    label: ::String
                                  }
                                },
                              ]?
                            }?,
                            merge: {
                              name: ::String,
                              inputs: Array[::String],
                              source: ::String,
                              primary_keys: Array[
                                Array[::String],
                              ]
                            }?,
                            union: {
                              name: ::String,
                              inputs: Array[::String],
                              union_type: ("ALL" | "DISTINCT")
                            }?,
                            pii_detection: {
                              name: ::String,
                              inputs: Array[::String],
                              pii_type: ("RowAudit" | "RowMasking" | "ColumnAudit" | "ColumnMasking"),
                              entity_types_to_detect: Array[::String],
                              output_column_name: ::String?,
                              sample_fraction: ::Float?,
                              threshold_fraction: ::Float?,
                              mask_value: ::String?
                            }?,
                            aggregate: {
                              name: ::String,
                              inputs: Array[::String],
                              groups: Array[
                                Array[::String],
                              ],
                              aggs: Array[
                                {
                                  column: Array[::String],
                                  agg_func: ("avg" | "countDistinct" | "count" | "first" | "last" | "kurtosis" | "max" | "min" | "skewness" | "stddev_samp" | "stddev_pop" | "sum" | "sumDistinct" | "var_samp" | "var_pop")
                                },
                              ]
                            }?,
                            drop_duplicates: {
                              name: ::String,
                              inputs: Array[::String],
                              columns: Array[
                                Array[::String],
                              ]?
                            }?,
                            governed_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              table: ::String,
                              database: ::String,
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                              }?
                            }?,
                            governed_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              partition_predicate: ::String?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?
                              }?
                            }?,
                            microsoft_sql_server_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            my_sql_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            oracle_sql_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            postgre_sql_catalog_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String
                            }?,
                            microsoft_sql_server_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String
                            }?,
                            my_sql_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String
                            }?,
                            oracle_sql_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String
                            }?,
                            postgre_sql_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              database: ::String,
                              table: ::String
                            }?,
                            dynamic_transform: {
                              name: ::String,
                              transform_name: ::String,
                              inputs: Array[::String],
                              parameters: Array[
                                {
                                  name: ::String,
                                  type: ("str" | "int" | "float" | "complex" | "bool" | "list" | "null"),
                                  validation_rule: ::String?,
                                  validation_message: ::String?,
                                  value: Array[::String]?,
                                  list_type: ("str" | "int" | "float" | "complex" | "bool" | "list" | "null")?,
                                  is_optional: bool?
                                },
                              ]?,
                              function_name: ::String,
                              path: ::String,
                              version: ::String?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            evaluate_data_quality: {
                              name: ::String,
                              inputs: Array[::String],
                              ruleset: ::String,
                              output: ("PrimaryInput" | "EvaluationResults")?,
                              publishing_options: {
                                evaluation_context: ::String?,
                                results_s3_prefix: ::String?,
                                cloud_watch_metrics_enabled: bool?,
                                results_publishing_enabled: bool?
                              }?,
                              stop_job_on_failure_options: {
                                stop_job_on_failure_timing: ("Immediate" | "AfterDataLoad")?
                              }?
                            }?,
                            s3_catalog_hudi_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              additional_hudi_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            catalog_hudi_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              additional_hudi_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_hudi_source: {
                              name: ::String,
                              paths: Array[::String],
                              additional_hudi_options: Hash[::String, ::String]?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?,
                                enable_sample_path: bool?,
                                sample_path: ::String?
                              }?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_hudi_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              table: ::String,
                              database: ::String,
                              additional_options: Hash[::String, ::String],
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                              }?
                            }?,
                            s3_hudi_direct_target: {
                              name: ::String,
                              inputs: Array[::String],
                              path: ::String,
                              compression: ("gzip" | "lzo" | "uncompressed" | "snappy"),
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                              additional_options: Hash[::String, ::String],
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                table: ::String?,
                                database: ::String?
                              }?
                            }?,
                            direct_jdbc_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              connection_name: ::String,
                              connection_type: ("sqlserver" | "mysql" | "oracle" | "postgresql" | "redshift"),
                              redshift_tmp_dir: ::String?
                            }?,
                            s3_catalog_delta_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              additional_delta_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            catalog_delta_source: {
                              name: ::String,
                              database: ::String,
                              table: ::String,
                              additional_delta_options: Hash[::String, ::String]?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_delta_source: {
                              name: ::String,
                              paths: Array[::String],
                              additional_delta_options: Hash[::String, ::String]?,
                              additional_options: {
                                bounded_size: ::Integer?,
                                bounded_files: ::Integer?,
                                enable_sample_path: bool?,
                                sample_path: ::String?
                              }?,
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            s3_delta_catalog_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              table: ::String,
                              database: ::String,
                              additional_options: Hash[::String, ::String]?,
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                              }?
                            }?,
                            s3_delta_direct_target: {
                              name: ::String,
                              inputs: Array[::String],
                              partition_keys: Array[
                                Array[::String],
                              ]?,
                              path: ::String,
                              compression: ("uncompressed" | "snappy"),
                              format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                              additional_options: Hash[::String, ::String]?,
                              schema_change_policy: {
                                enable_update_catalog: bool?,
                                update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                table: ::String?,
                                database: ::String?
                              }?
                            }?,
                            amazon_redshift_source: {
                              name: ::String?,
                              data: {
                                access_type: ::String?,
                                source_type: ::String?,
                                connection: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                schema: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                table: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_database: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_table: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_redshift_schema: ::String?,
                                catalog_redshift_table: ::String?,
                                temp_dir: ::String?,
                                iam_role: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                advanced_options: Array[
                                  {
                                    key: ::String?,
                                    value: ::String?
                                  },
                                ]?,
                                sample_query: ::String?,
                                pre_action: ::String?,
                                post_action: ::String?,
                                action: ::String?,
                                table_prefix: ::String?,
                                upsert: bool?,
                                merge_action: ::String?,
                                merge_when_matched: ::String?,
                                merge_when_not_matched: ::String?,
                                merge_clause: ::String?,
                                crawler_connection: ::String?,
                                table_schema: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?,
                                staging_table: ::String?,
                                selected_columns: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?
                              }?
                            }?,
                            amazon_redshift_target: {
                              name: ::String?,
                              data: {
                                access_type: ::String?,
                                source_type: ::String?,
                                connection: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                schema: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                table: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_database: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_table: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                catalog_redshift_schema: ::String?,
                                catalog_redshift_table: ::String?,
                                temp_dir: ::String?,
                                iam_role: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                advanced_options: Array[
                                  {
                                    key: ::String?,
                                    value: ::String?
                                  },
                                ]?,
                                sample_query: ::String?,
                                pre_action: ::String?,
                                post_action: ::String?,
                                action: ::String?,
                                table_prefix: ::String?,
                                upsert: bool?,
                                merge_action: ::String?,
                                merge_when_matched: ::String?,
                                merge_when_not_matched: ::String?,
                                merge_clause: ::String?,
                                crawler_connection: ::String?,
                                table_schema: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?,
                                staging_table: ::String?,
                                selected_columns: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?
                              }?,
                              inputs: Array[::String]?
                            }?,
                            evaluate_data_quality_multi_frame: {
                              name: ::String,
                              inputs: Array[::String],
                              additional_data_sources: Hash[::String, ::String]?,
                              ruleset: ::String,
                              publishing_options: {
                                evaluation_context: ::String?,
                                results_s3_prefix: ::String?,
                                cloud_watch_metrics_enabled: bool?,
                                results_publishing_enabled: bool?
                              }?,
                              additional_options: Hash[("performanceTuning.caching" | "observations.scope"), ::String]?,
                              stop_job_on_failure_options: {
                                stop_job_on_failure_timing: ("Immediate" | "AfterDataLoad")?
                              }?
                            }?,
                            recipe: {
                              name: ::String,
                              inputs: Array[::String],
                              recipe_reference: {
                                recipe_arn: ::String,
                                recipe_version: ::String
                              }
                            }?,
                            snowflake_source: {
                              name: ::String,
                              data: {
                                source_type: ::String?,
                                connection: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                schema: ::String?,
                                table: ::String?,
                                database: ::String?,
                                temp_dir: ::String?,
                                iam_role: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                additional_options: Hash[::String, ::String]?,
                                sample_query: ::String?,
                                pre_action: ::String?,
                                post_action: ::String?,
                                action: ::String?,
                                upsert: bool?,
                                merge_action: ::String?,
                                merge_when_matched: ::String?,
                                merge_when_not_matched: ::String?,
                                merge_clause: ::String?,
                                staging_table: ::String?,
                                selected_columns: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?,
                                auto_pushdown: bool?,
                                table_schema: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?
                              },
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            snowflake_target: {
                              name: ::String,
                              data: {
                                source_type: ::String?,
                                connection: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                schema: ::String?,
                                table: ::String?,
                                database: ::String?,
                                temp_dir: ::String?,
                                iam_role: {
                                  value: ::String?,
                                  label: ::String?,
                                  description: ::String?
                                }?,
                                additional_options: Hash[::String, ::String]?,
                                sample_query: ::String?,
                                pre_action: ::String?,
                                post_action: ::String?,
                                action: ::String?,
                                upsert: bool?,
                                merge_action: ::String?,
                                merge_when_matched: ::String?,
                                merge_when_not_matched: ::String?,
                                merge_clause: ::String?,
                                staging_table: ::String?,
                                selected_columns: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?,
                                auto_pushdown: bool?,
                                table_schema: Array[
                                  {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  },
                                ]?
                              },
                              inputs: Array[::String]?
                            }?,
                            connector_data_source: {
                              name: ::String,
                              connection_type: ::String,
                              data: Hash[::String, ::String],
                              output_schemas: Array[
                                {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?
                                    },
                                  ]?
                                },
                              ]?
                            }?,
                            connector_data_target: {
                              name: ::String,
                              connection_type: ::String,
                              data: Hash[::String, ::String],
                              inputs: Array[::String]?
                            }?
                          }],
                        ?execution_class: ("FLEX" | "STANDARD"),
                        ?source_control_details: {
                          provider: ("GITHUB" | "GITLAB" | "BITBUCKET" | "AWS_CODE_COMMIT")?,
                          repository: ::String?,
                          owner: ::String?,
                          branch: ::String?,
                          folder: ::String?,
                          last_commit_id: ::String?,
                          auth_strategy: ("PERSONAL_ACCESS_TOKEN" | "AWS_SECRETS_MANAGER")?,
                          auth_token: ::String?
                        },
                        ?maintenance_window: ::String
                      ) -> _CreateJobResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateJobResponseSuccess

      interface _CreateMLTransformResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateMLTransformResponse]
        def transform_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_ml_transform-instance_method
      def create_ml_transform: (
                                 name: ::String,
                                 ?description: ::String,
                                 input_record_tables: Array[
                                   {
                                     database_name: ::String,
                                     table_name: ::String,
                                     catalog_id: ::String?,
                                     connection_name: ::String?,
                                     additional_options: Hash[::String, ::String]?
                                   },
                                 ],
                                 parameters: {
                                   transform_type: ("FIND_MATCHES"),
                                   find_matches_parameters: {
                                     primary_key_column_name: ::String?,
                                     precision_recall_tradeoff: ::Float?,
                                     accuracy_cost_tradeoff: ::Float?,
                                     enforce_provided_labels: bool?
                                   }?
                                 },
                                 role: ::String,
                                 ?glue_version: ::String,
                                 ?max_capacity: ::Float,
                                 ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                                 ?number_of_workers: ::Integer,
                                 ?timeout: ::Integer,
                                 ?max_retries: ::Integer,
                                 ?tags: Hash[::String, ::String],
                                 ?transform_encryption: {
                                   ml_user_data_encryption: {
                                     ml_user_data_encryption_mode: ("DISABLED" | "SSE-KMS"),
                                     kms_key_id: ::String?
                                   }?,
                                   task_run_security_configuration_name: ::String?
                                 }
                               ) -> _CreateMLTransformResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateMLTransformResponseSuccess

      interface _CreatePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePartitionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_partition-instance_method
      def create_partition: (
                              ?catalog_id: ::String,
                              database_name: ::String,
                              table_name: ::String,
                              partition_input: {
                                values: Array[::String]?,
                                last_access_time: ::Time?,
                                storage_descriptor: {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?,
                                      comment: ::String?,
                                      parameters: Hash[::String, ::String]?
                                    },
                                  ]?,
                                  location: ::String?,
                                  additional_locations: Array[::String]?,
                                  input_format: ::String?,
                                  output_format: ::String?,
                                  compressed: bool?,
                                  number_of_buckets: ::Integer?,
                                  serde_info: {
                                    name: ::String?,
                                    serialization_library: ::String?,
                                    parameters: Hash[::String, ::String]?
                                  }?,
                                  bucket_columns: Array[::String]?,
                                  sort_columns: Array[
                                    {
                                      column: ::String,
                                      sort_order: ::Integer
                                    },
                                  ]?,
                                  parameters: Hash[::String, ::String]?,
                                  skewed_info: {
                                    skewed_column_names: Array[::String]?,
                                    skewed_column_values: Array[::String]?,
                                    skewed_column_value_location_maps: Hash[::String, ::String]?
                                  }?,
                                  stored_as_sub_directories: bool?,
                                  schema_reference: {
                                    schema_id: {
                                      schema_arn: ::String?,
                                      schema_name: ::String?,
                                      registry_name: ::String?
                                    }?,
                                    schema_version_id: ::String?,
                                    schema_version_number: ::Integer?
                                  }?
                                }?,
                                parameters: Hash[::String, ::String]?,
                                last_analyzed_time: ::Time?
                              }
                            ) -> _CreatePartitionResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePartitionResponseSuccess

      interface _CreatePartitionIndexResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreatePartitionIndexResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_partition_index-instance_method
      def create_partition_index: (
                                    ?catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    partition_index: {
                                      keys: Array[::String],
                                      index_name: ::String
                                    }
                                  ) -> _CreatePartitionIndexResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePartitionIndexResponseSuccess

      interface _CreateRegistryResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateRegistryResponse]
        def registry_arn: () -> ::String
        def registry_name: () -> ::String
        def description: () -> ::String
        def tags: () -> ::Hash[::String, ::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_registry-instance_method
      def create_registry: (
                             registry_name: ::String,
                             ?description: ::String,
                             ?tags: Hash[::String, ::String]
                           ) -> _CreateRegistryResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateRegistryResponseSuccess

      interface _CreateSchemaResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSchemaResponse]
        def registry_name: () -> ::String
        def registry_arn: () -> ::String
        def schema_name: () -> ::String
        def schema_arn: () -> ::String
        def description: () -> ::String
        def data_format: () -> ("AVRO" | "JSON" | "PROTOBUF")
        def compatibility: () -> ("NONE" | "DISABLED" | "BACKWARD" | "BACKWARD_ALL" | "FORWARD" | "FORWARD_ALL" | "FULL" | "FULL_ALL")
        def schema_checkpoint: () -> ::Integer
        def latest_schema_version: () -> ::Integer
        def next_schema_version: () -> ::Integer
        def schema_status: () -> ("AVAILABLE" | "PENDING" | "DELETING")
        def tags: () -> ::Hash[::String, ::String]
        def schema_version_id: () -> ::String
        def schema_version_status: () -> ("AVAILABLE" | "PENDING" | "FAILURE" | "DELETING")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_schema-instance_method
      def create_schema: (
                           ?registry_id: {
                             registry_name: ::String?,
                             registry_arn: ::String?
                           },
                           schema_name: ::String,
                           data_format: ("AVRO" | "JSON" | "PROTOBUF"),
                           ?compatibility: ("NONE" | "DISABLED" | "BACKWARD" | "BACKWARD_ALL" | "FORWARD" | "FORWARD_ALL" | "FULL" | "FULL_ALL"),
                           ?description: ::String,
                           ?tags: Hash[::String, ::String],
                           ?schema_definition: ::String
                         ) -> _CreateSchemaResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSchemaResponseSuccess

      interface _CreateScriptResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateScriptResponse]
        def python_script: () -> ::String
        def scala_code: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_script-instance_method
      def create_script: (
                           ?dag_nodes: Array[
                             {
                               id: ::String,
                               node_type: ::String,
                               args: Array[
                                 {
                                   name: ::String,
                                   value: ::String,
                                   param: bool?
                                 },
                               ],
                               line_number: ::Integer?
                             },
                           ],
                           ?dag_edges: Array[
                             {
                               source: ::String,
                               target: ::String,
                               target_parameter: ::String?
                             },
                           ],
                           ?language: ("PYTHON" | "SCALA")
                         ) -> _CreateScriptResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateScriptResponseSuccess

      interface _CreateSecurityConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSecurityConfigurationResponse]
        def name: () -> ::String
        def created_timestamp: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_security_configuration-instance_method
      def create_security_configuration: (
                                           name: ::String,
                                           encryption_configuration: {
                                             s3_encryption: Array[
                                               {
                                                 s3_encryption_mode: ("DISABLED" | "SSE-KMS" | "SSE-S3")?,
                                                 kms_key_arn: ::String?
                                               },
                                             ]?,
                                             cloud_watch_encryption: {
                                               cloud_watch_encryption_mode: ("DISABLED" | "SSE-KMS")?,
                                               kms_key_arn: ::String?
                                             }?,
                                             job_bookmarks_encryption: {
                                               job_bookmarks_encryption_mode: ("DISABLED" | "CSE-KMS")?,
                                               kms_key_arn: ::String?
                                             }?
                                           }
                                         ) -> _CreateSecurityConfigurationResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSecurityConfigurationResponseSuccess

      interface _CreateSessionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSessionResponse]
        def session: () -> Types::Session
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_session-instance_method
      def create_session: (
                            id: ::String,
                            ?description: ::String,
                            role: ::String,
                            command: {
                              name: ::String?,
                              python_version: ::String?
                            },
                            ?timeout: ::Integer,
                            ?idle_timeout: ::Integer,
                            ?default_arguments: Hash[::String, ::String],
                            ?connections: {
                              connections: Array[::String]?
                            },
                            ?max_capacity: ::Float,
                            ?number_of_workers: ::Integer,
                            ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                            ?security_configuration: ::String,
                            ?glue_version: ::String,
                            ?tags: Hash[::String, ::String],
                            ?request_origin: ::String
                          ) -> _CreateSessionResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSessionResponseSuccess

      interface _CreateTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTableResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_table-instance_method
      def create_table: (
                          ?catalog_id: ::String,
                          database_name: ::String,
                          table_input: {
                            name: ::String,
                            description: ::String?,
                            owner: ::String?,
                            last_access_time: ::Time?,
                            last_analyzed_time: ::Time?,
                            retention: ::Integer?,
                            storage_descriptor: {
                              columns: Array[
                                {
                                  name: ::String,
                                  type: ::String?,
                                  comment: ::String?,
                                  parameters: Hash[::String, ::String]?
                                },
                              ]?,
                              location: ::String?,
                              additional_locations: Array[::String]?,
                              input_format: ::String?,
                              output_format: ::String?,
                              compressed: bool?,
                              number_of_buckets: ::Integer?,
                              serde_info: {
                                name: ::String?,
                                serialization_library: ::String?,
                                parameters: Hash[::String, ::String]?
                              }?,
                              bucket_columns: Array[::String]?,
                              sort_columns: Array[
                                {
                                  column: ::String,
                                  sort_order: ::Integer
                                },
                              ]?,
                              parameters: Hash[::String, ::String]?,
                              skewed_info: {
                                skewed_column_names: Array[::String]?,
                                skewed_column_values: Array[::String]?,
                                skewed_column_value_location_maps: Hash[::String, ::String]?
                              }?,
                              stored_as_sub_directories: bool?,
                              schema_reference: {
                                schema_id: {
                                  schema_arn: ::String?,
                                  schema_name: ::String?,
                                  registry_name: ::String?
                                }?,
                                schema_version_id: ::String?,
                                schema_version_number: ::Integer?
                              }?
                            }?,
                            partition_keys: Array[
                              {
                                name: ::String,
                                type: ::String?,
                                comment: ::String?,
                                parameters: Hash[::String, ::String]?
                              },
                            ]?,
                            view_original_text: ::String?,
                            view_expanded_text: ::String?,
                            table_type: ::String?,
                            parameters: Hash[::String, ::String]?,
                            target_table: {
                              catalog_id: ::String?,
                              database_name: ::String?,
                              name: ::String?,
                              region: ::String?
                            }?
                          },
                          ?partition_indexes: Array[
                            {
                              keys: Array[::String],
                              index_name: ::String
                            },
                          ],
                          ?transaction_id: ::String,
                          ?open_table_format_input: {
                            iceberg_input: {
                              metadata_operation: ("CREATE"),
                              version: ::String?
                            }?
                          }
                        ) -> _CreateTableResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTableResponseSuccess

      interface _CreateTableOptimizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTableOptimizerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_table_optimizer-instance_method
      def create_table_optimizer: (
                                    catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    type: ("compaction"),
                                    table_optimizer_configuration: {
                                      role_arn: ::String?,
                                      enabled: bool?
                                    }
                                  ) -> _CreateTableOptimizerResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTableOptimizerResponseSuccess

      interface _CreateTriggerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateTriggerResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_trigger-instance_method
      def create_trigger: (
                            name: ::String,
                            ?workflow_name: ::String,
                            type: ("SCHEDULED" | "CONDITIONAL" | "ON_DEMAND" | "EVENT"),
                            ?schedule: ::String,
                            ?predicate: {
                              logical: ("AND" | "ANY")?,
                              conditions: Array[
                                {
                                  logical_operator: ("EQUALS")?,
                                  job_name: ::String?,
                                  state: ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT" | "ERROR" | "WAITING" | "EXPIRED")?,
                                  crawler_name: ::String?,
                                  crawl_state: ("RUNNING" | "CANCELLING" | "CANCELLED" | "SUCCEEDED" | "FAILED" | "ERROR")?
                                },
                              ]?
                            },
                            actions: Array[
                              {
                                job_name: ::String?,
                                arguments: Hash[::String, ::String]?,
                                timeout: ::Integer?,
                                security_configuration: ::String?,
                                notification_property: {
                                  notify_delay_after: ::Integer?
                                }?,
                                crawler_name: ::String?
                              },
                            ],
                            ?description: ::String,
                            ?start_on_creation: bool,
                            ?tags: Hash[::String, ::String],
                            ?event_batching_condition: {
                              batch_size: ::Integer,
                              batch_window: ::Integer?
                            }
                          ) -> _CreateTriggerResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateTriggerResponseSuccess

      interface _CreateUserDefinedFunctionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateUserDefinedFunctionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_user_defined_function-instance_method
      def create_user_defined_function: (
                                          ?catalog_id: ::String,
                                          database_name: ::String,
                                          function_input: {
                                            function_name: ::String?,
                                            class_name: ::String?,
                                            owner_name: ::String?,
                                            owner_type: ("USER" | "ROLE" | "GROUP")?,
                                            resource_uris: Array[
                                              {
                                                resource_type: ("JAR" | "FILE" | "ARCHIVE")?,
                                                uri: ::String?
                                              },
                                            ]?
                                          }
                                        ) -> _CreateUserDefinedFunctionResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUserDefinedFunctionResponseSuccess

      interface _CreateWorkflowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateWorkflowResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#create_workflow-instance_method
      def create_workflow: (
                             name: ::String,
                             ?description: ::String,
                             ?default_run_properties: Hash[::String, ::String],
                             ?tags: Hash[::String, ::String],
                             ?max_concurrent_runs: ::Integer
                           ) -> _CreateWorkflowResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateWorkflowResponseSuccess

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

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

      interface _DeleteColumnStatisticsForPartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteColumnStatisticsForPartitionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_column_statistics_for_partition-instance_method
      def delete_column_statistics_for_partition: (
                                                    ?catalog_id: ::String,
                                                    database_name: ::String,
                                                    table_name: ::String,
                                                    partition_values: Array[::String],
                                                    column_name: ::String
                                                  ) -> _DeleteColumnStatisticsForPartitionResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteColumnStatisticsForPartitionResponseSuccess

      interface _DeleteColumnStatisticsForTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteColumnStatisticsForTableResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_column_statistics_for_table-instance_method
      def delete_column_statistics_for_table: (
                                                ?catalog_id: ::String,
                                                database_name: ::String,
                                                table_name: ::String,
                                                column_name: ::String
                                              ) -> _DeleteColumnStatisticsForTableResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteColumnStatisticsForTableResponseSuccess

      interface _DeleteConnectionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteConnectionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_connection-instance_method
      def delete_connection: (
                               ?catalog_id: ::String,
                               connection_name: ::String
                             ) -> _DeleteConnectionResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteConnectionResponseSuccess

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

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

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

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

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

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

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

      interface _DeletePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeletePartitionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_partition-instance_method
      def delete_partition: (
                              ?catalog_id: ::String,
                              database_name: ::String,
                              table_name: ::String,
                              partition_values: Array[::String]
                            ) -> _DeletePartitionResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeletePartitionResponseSuccess

      interface _DeletePartitionIndexResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeletePartitionIndexResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_partition_index-instance_method
      def delete_partition_index: (
                                    ?catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    index_name: ::String
                                  ) -> _DeletePartitionIndexResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeletePartitionIndexResponseSuccess

      interface _DeleteRegistryResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteRegistryResponse]
        def registry_name: () -> ::String
        def registry_arn: () -> ::String
        def status: () -> ("AVAILABLE" | "DELETING")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_registry-instance_method
      def delete_registry: (
                             registry_id: {
                               registry_name: ::String?,
                               registry_arn: ::String?
                             }
                           ) -> _DeleteRegistryResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteRegistryResponseSuccess

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

      interface _DeleteSchemaResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteSchemaResponse]
        def schema_arn: () -> ::String
        def schema_name: () -> ::String
        def status: () -> ("AVAILABLE" | "PENDING" | "DELETING")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_schema-instance_method
      def delete_schema: (
                           schema_id: {
                             schema_arn: ::String?,
                             schema_name: ::String?,
                             registry_name: ::String?
                           }
                         ) -> _DeleteSchemaResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteSchemaResponseSuccess

      interface _DeleteSchemaVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteSchemaVersionsResponse]
        def schema_version_errors: () -> ::Array[Types::SchemaVersionErrorItem]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_schema_versions-instance_method
      def delete_schema_versions: (
                                    schema_id: {
                                      schema_arn: ::String?,
                                      schema_name: ::String?,
                                      registry_name: ::String?
                                    },
                                    versions: ::String
                                  ) -> _DeleteSchemaVersionsResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteSchemaVersionsResponseSuccess

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

      interface _DeleteSessionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteSessionResponse]
        def id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_session-instance_method
      def delete_session: (
                            id: ::String,
                            ?request_origin: ::String
                          ) -> _DeleteSessionResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteSessionResponseSuccess

      interface _DeleteTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteTableResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_table-instance_method
      def delete_table: (
                          ?catalog_id: ::String,
                          database_name: ::String,
                          name: ::String,
                          ?transaction_id: ::String
                        ) -> _DeleteTableResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteTableResponseSuccess

      interface _DeleteTableOptimizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteTableOptimizerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_table_optimizer-instance_method
      def delete_table_optimizer: (
                                    catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    type: ("compaction")
                                  ) -> _DeleteTableOptimizerResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteTableOptimizerResponseSuccess

      interface _DeleteTableVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteTableVersionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_table_version-instance_method
      def delete_table_version: (
                                  ?catalog_id: ::String,
                                  database_name: ::String,
                                  table_name: ::String,
                                  version_id: ::String
                                ) -> _DeleteTableVersionResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteTableVersionResponseSuccess

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

      interface _DeleteUserDefinedFunctionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteUserDefinedFunctionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#delete_user_defined_function-instance_method
      def delete_user_defined_function: (
                                          ?catalog_id: ::String,
                                          database_name: ::String,
                                          function_name: ::String
                                        ) -> _DeleteUserDefinedFunctionResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteUserDefinedFunctionResponseSuccess

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

      interface _GetBlueprintResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetBlueprintResponse]
        def blueprint: () -> Types::Blueprint
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_blueprint-instance_method
      def get_blueprint: (
                           name: ::String,
                           ?include_blueprint: bool,
                           ?include_parameter_spec: bool
                         ) -> _GetBlueprintResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBlueprintResponseSuccess

      interface _GetBlueprintRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetBlueprintRunResponse]
        def blueprint_run: () -> Types::BlueprintRun
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_blueprint_run-instance_method
      def get_blueprint_run: (
                               blueprint_name: ::String,
                               run_id: ::String
                             ) -> _GetBlueprintRunResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBlueprintRunResponseSuccess

      interface _GetBlueprintRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetBlueprintRunsResponse]
        def blueprint_runs: () -> ::Array[Types::BlueprintRun]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_blueprint_runs-instance_method
      def get_blueprint_runs: (
                                blueprint_name: ::String,
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _GetBlueprintRunsResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBlueprintRunsResponseSuccess

      interface _GetCatalogImportStatusResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCatalogImportStatusResponse]
        def import_status: () -> Types::CatalogImportStatus
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_catalog_import_status-instance_method
      def get_catalog_import_status: (
                                       ?catalog_id: ::String
                                     ) -> _GetCatalogImportStatusResponseSuccess
                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCatalogImportStatusResponseSuccess

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

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

      interface _GetColumnStatisticsForPartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetColumnStatisticsForPartitionResponse]
        def column_statistics_list: () -> ::Array[Types::ColumnStatistics]
        def errors: () -> ::Array[Types::ColumnError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_column_statistics_for_partition-instance_method
      def get_column_statistics_for_partition: (
                                                 ?catalog_id: ::String,
                                                 database_name: ::String,
                                                 table_name: ::String,
                                                 partition_values: Array[::String],
                                                 column_names: Array[::String]
                                               ) -> _GetColumnStatisticsForPartitionResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetColumnStatisticsForPartitionResponseSuccess

      interface _GetColumnStatisticsForTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetColumnStatisticsForTableResponse]
        def column_statistics_list: () -> ::Array[Types::ColumnStatistics]
        def errors: () -> ::Array[Types::ColumnError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_column_statistics_for_table-instance_method
      def get_column_statistics_for_table: (
                                             ?catalog_id: ::String,
                                             database_name: ::String,
                                             table_name: ::String,
                                             column_names: Array[::String]
                                           ) -> _GetColumnStatisticsForTableResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetColumnStatisticsForTableResponseSuccess

      interface _GetColumnStatisticsTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetColumnStatisticsTaskRunResponse]
        def column_statistics_task_run: () -> Types::ColumnStatisticsTaskRun
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_column_statistics_task_run-instance_method
      def get_column_statistics_task_run: (
                                            column_statistics_task_run_id: ::String
                                          ) -> _GetColumnStatisticsTaskRunResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetColumnStatisticsTaskRunResponseSuccess

      interface _GetColumnStatisticsTaskRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetColumnStatisticsTaskRunsResponse]
        def column_statistics_task_runs: () -> ::Array[Types::ColumnStatisticsTaskRun]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_column_statistics_task_runs-instance_method
      def get_column_statistics_task_runs: (
                                             database_name: ::String,
                                             table_name: ::String,
                                             ?max_results: ::Integer,
                                             ?next_token: ::String
                                           ) -> _GetColumnStatisticsTaskRunsResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetColumnStatisticsTaskRunsResponseSuccess

      interface _GetConnectionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetConnectionResponse]
        def connection: () -> Types::Connection
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_connection-instance_method
      def get_connection: (
                            ?catalog_id: ::String,
                            name: ::String,
                            ?hide_password: bool
                          ) -> _GetConnectionResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetConnectionResponseSuccess

      interface _GetConnectionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetConnectionsResponse]
        def connection_list: () -> ::Array[Types::Connection]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_connections-instance_method
      def get_connections: (
                             ?catalog_id: ::String,
                             ?filter: {
                               match_criteria: Array[::String]?,
                               connection_type: ("JDBC" | "SFTP" | "MONGODB" | "KAFKA" | "NETWORK" | "MARKETPLACE" | "CUSTOM" | "SALESFORCE")?
                             },
                             ?hide_password: bool,
                             ?next_token: ::String,
                             ?max_results: ::Integer
                           ) -> _GetConnectionsResponseSuccess
                         | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetConnectionsResponseSuccess

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

      interface _GetCrawlerMetricsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCrawlerMetricsResponse]
        def crawler_metrics_list: () -> ::Array[Types::CrawlerMetrics]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_crawler_metrics-instance_method
      def get_crawler_metrics: (
                                 ?crawler_name_list: Array[::String],
                                 ?max_results: ::Integer,
                                 ?next_token: ::String
                               ) -> _GetCrawlerMetricsResponseSuccess
                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCrawlerMetricsResponseSuccess

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

      interface _GetCustomEntityTypeResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetCustomEntityTypeResponse]
        def name: () -> ::String
        def regex_string: () -> ::String
        def context_words: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_custom_entity_type-instance_method
      def get_custom_entity_type: (
                                    name: ::String
                                  ) -> _GetCustomEntityTypeResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetCustomEntityTypeResponseSuccess

      interface _GetDataCatalogEncryptionSettingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataCatalogEncryptionSettingsResponse]
        def data_catalog_encryption_settings: () -> Types::DataCatalogEncryptionSettings
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_data_catalog_encryption_settings-instance_method
      def get_data_catalog_encryption_settings: (
                                                  ?catalog_id: ::String
                                                ) -> _GetDataCatalogEncryptionSettingsResponseSuccess
                                              | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataCatalogEncryptionSettingsResponseSuccess

      interface _GetDataQualityResultResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataQualityResultResponse]
        def result_id: () -> ::String
        def score: () -> ::Float
        def data_source: () -> Types::DataSource
        def ruleset_name: () -> ::String
        def evaluation_context: () -> ::String
        def started_on: () -> ::Time
        def completed_on: () -> ::Time
        def job_name: () -> ::String
        def job_run_id: () -> ::String
        def ruleset_evaluation_run_id: () -> ::String
        def rule_results: () -> ::Array[Types::DataQualityRuleResult]
        def analyzer_results: () -> ::Array[Types::DataQualityAnalyzerResult]
        def observations: () -> ::Array[Types::DataQualityObservation]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_data_quality_result-instance_method
      def get_data_quality_result: (
                                     result_id: ::String
                                   ) -> _GetDataQualityResultResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataQualityResultResponseSuccess

      interface _GetDataQualityRuleRecommendationRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataQualityRuleRecommendationRunResponse]
        def run_id: () -> ::String
        def data_source: () -> Types::DataSource
        def role: () -> ::String
        def number_of_workers: () -> ::Integer
        def timeout: () -> ::Integer
        def status: () -> ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT")
        def error_string: () -> ::String
        def started_on: () -> ::Time
        def last_modified_on: () -> ::Time
        def completed_on: () -> ::Time
        def execution_time: () -> ::Integer
        def recommended_ruleset: () -> ::String
        def created_ruleset_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_data_quality_rule_recommendation_run-instance_method
      def get_data_quality_rule_recommendation_run: (
                                                      run_id: ::String
                                                    ) -> _GetDataQualityRuleRecommendationRunResponseSuccess
                                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataQualityRuleRecommendationRunResponseSuccess

      interface _GetDataQualityRulesetResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataQualityRulesetResponse]
        def name: () -> ::String
        def description: () -> ::String
        def ruleset: () -> ::String
        def target_table: () -> Types::DataQualityTargetTable
        def created_on: () -> ::Time
        def last_modified_on: () -> ::Time
        def recommendation_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_data_quality_ruleset-instance_method
      def get_data_quality_ruleset: (
                                      name: ::String
                                    ) -> _GetDataQualityRulesetResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataQualityRulesetResponseSuccess

      interface _GetDataQualityRulesetEvaluationRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataQualityRulesetEvaluationRunResponse]
        def run_id: () -> ::String
        def data_source: () -> Types::DataSource
        def role: () -> ::String
        def number_of_workers: () -> ::Integer
        def timeout: () -> ::Integer
        def additional_run_options: () -> Types::DataQualityEvaluationRunAdditionalRunOptions
        def status: () -> ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT")
        def error_string: () -> ::String
        def started_on: () -> ::Time
        def last_modified_on: () -> ::Time
        def completed_on: () -> ::Time
        def execution_time: () -> ::Integer
        def ruleset_names: () -> ::Array[::String]
        def result_ids: () -> ::Array[::String]
        def additional_data_sources: () -> ::Hash[::String, Types::DataSource]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_data_quality_ruleset_evaluation_run-instance_method
      def get_data_quality_ruleset_evaluation_run: (
                                                     run_id: ::String
                                                   ) -> _GetDataQualityRulesetEvaluationRunResponseSuccess
                                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataQualityRulesetEvaluationRunResponseSuccess

      interface _GetDatabaseResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDatabaseResponse]
        def database: () -> Types::Database
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_database-instance_method
      def get_database: (
                          ?catalog_id: ::String,
                          name: ::String
                        ) -> _GetDatabaseResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDatabaseResponseSuccess

      interface _GetDatabasesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDatabasesResponse]
        def database_list: () -> ::Array[Types::Database]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_databases-instance_method
      def get_databases: (
                           ?catalog_id: ::String,
                           ?next_token: ::String,
                           ?max_results: ::Integer,
                           ?resource_share_type: ("FOREIGN" | "ALL" | "FEDERATED")
                         ) -> _GetDatabasesResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDatabasesResponseSuccess

      interface _GetDataflowGraphResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDataflowGraphResponse]
        def dag_nodes: () -> ::Array[Types::CodeGenNode]
        def dag_edges: () -> ::Array[Types::CodeGenEdge]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_dataflow_graph-instance_method
      def get_dataflow_graph: (
                                ?python_script: ::String
                              ) -> _GetDataflowGraphResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDataflowGraphResponseSuccess

      interface _GetDevEndpointResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetDevEndpointResponse]
        def dev_endpoint: () -> Types::DevEndpoint
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_dev_endpoint-instance_method
      def get_dev_endpoint: (
                              endpoint_name: ::String
                            ) -> _GetDevEndpointResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDevEndpointResponseSuccess

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

      interface _GetJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetJobResponse]
        def job: () -> Types::Job
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_job-instance_method
      def get_job: (
                     job_name: ::String
                   ) -> _GetJobResponseSuccess
                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetJobResponseSuccess

      interface _GetJobBookmarkResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetJobBookmarkResponse]
        def job_bookmark_entry: () -> Types::JobBookmarkEntry
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_job_bookmark-instance_method
      def get_job_bookmark: (
                              job_name: ::String,
                              ?run_id: ::String
                            ) -> _GetJobBookmarkResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetJobBookmarkResponseSuccess

      interface _GetJobRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetJobRunResponse]
        def job_run: () -> Types::JobRun
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_job_run-instance_method
      def get_job_run: (
                         job_name: ::String,
                         run_id: ::String,
                         ?predecessors_included: bool
                       ) -> _GetJobRunResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetJobRunResponseSuccess

      interface _GetJobRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetJobRunsResponse]
        def job_runs: () -> ::Array[Types::JobRun]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_job_runs-instance_method
      def get_job_runs: (
                          job_name: ::String,
                          ?next_token: ::String,
                          ?max_results: ::Integer
                        ) -> _GetJobRunsResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetJobRunsResponseSuccess

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

      interface _GetMLTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMLTaskRunResponse]
        def transform_id: () -> ::String
        def task_run_id: () -> ::String
        def status: () -> ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT")
        def log_group_name: () -> ::String
        def properties: () -> Types::TaskRunProperties
        def error_string: () -> ::String
        def started_on: () -> ::Time
        def last_modified_on: () -> ::Time
        def completed_on: () -> ::Time
        def execution_time: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_ml_task_run-instance_method
      def get_ml_task_run: (
                             transform_id: ::String,
                             task_run_id: ::String
                           ) -> _GetMLTaskRunResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMLTaskRunResponseSuccess

      interface _GetMLTaskRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMLTaskRunsResponse]
        def task_runs: () -> ::Array[Types::TaskRun]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_ml_task_runs-instance_method
      def get_ml_task_runs: (
                              transform_id: ::String,
                              ?next_token: ::String,
                              ?max_results: ::Integer,
                              ?filter: {
                                task_run_type: ("EVALUATION" | "LABELING_SET_GENERATION" | "IMPORT_LABELS" | "EXPORT_LABELS" | "FIND_MATCHES")?,
                                status: ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT")?,
                                started_before: ::Time?,
                                started_after: ::Time?
                              },
                              ?sort: {
                                column: ("TASK_RUN_TYPE" | "STATUS" | "STARTED"),
                                sort_direction: ("DESCENDING" | "ASCENDING")
                              }
                            ) -> _GetMLTaskRunsResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMLTaskRunsResponseSuccess

      interface _GetMLTransformResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMLTransformResponse]
        def transform_id: () -> ::String
        def name: () -> ::String
        def description: () -> ::String
        def status: () -> ("NOT_READY" | "READY" | "DELETING")
        def created_on: () -> ::Time
        def last_modified_on: () -> ::Time
        def input_record_tables: () -> ::Array[Types::GlueTable]
        def parameters: () -> Types::TransformParameters
        def evaluation_metrics: () -> Types::EvaluationMetrics
        def label_count: () -> ::Integer
        def schema: () -> ::Array[Types::SchemaColumn]
        def role: () -> ::String
        def glue_version: () -> ::String
        def max_capacity: () -> ::Float
        def worker_type: () -> ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X")
        def number_of_workers: () -> ::Integer
        def timeout: () -> ::Integer
        def max_retries: () -> ::Integer
        def transform_encryption: () -> Types::TransformEncryption
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_ml_transform-instance_method
      def get_ml_transform: (
                              transform_id: ::String
                            ) -> _GetMLTransformResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMLTransformResponseSuccess

      interface _GetMLTransformsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMLTransformsResponse]
        def transforms: () -> ::Array[Types::MLTransform]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_ml_transforms-instance_method
      def get_ml_transforms: (
                               ?next_token: ::String,
                               ?max_results: ::Integer,
                               ?filter: {
                                 name: ::String?,
                                 transform_type: ("FIND_MATCHES")?,
                                 status: ("NOT_READY" | "READY" | "DELETING")?,
                                 glue_version: ::String?,
                                 created_before: ::Time?,
                                 created_after: ::Time?,
                                 last_modified_before: ::Time?,
                                 last_modified_after: ::Time?,
                                 schema: Array[
                                   {
                                     name: ::String?,
                                     data_type: ::String?
                                   },
                                 ]?
                               },
                               ?sort: {
                                 column: ("NAME" | "TRANSFORM_TYPE" | "STATUS" | "CREATED" | "LAST_MODIFIED"),
                                 sort_direction: ("DESCENDING" | "ASCENDING")
                               }
                             ) -> _GetMLTransformsResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMLTransformsResponseSuccess

      interface _GetMappingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetMappingResponse]
        def mapping: () -> ::Array[Types::MappingEntry]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_mapping-instance_method
      def get_mapping: (
                         source: {
                           database_name: ::String,
                           table_name: ::String
                         },
                         ?sinks: Array[
                           {
                             database_name: ::String,
                             table_name: ::String
                           },
                         ],
                         ?location: {
                           jdbc: Array[
                             {
                               name: ::String,
                               value: ::String,
                               param: bool?
                             },
                           ]?,
                           s3: Array[
                             {
                               name: ::String,
                               value: ::String,
                               param: bool?
                             },
                           ]?,
                           dynamo_db: Array[
                             {
                               name: ::String,
                               value: ::String,
                               param: bool?
                             },
                           ]?
                         }
                       ) -> _GetMappingResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetMappingResponseSuccess

      interface _GetPartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPartitionResponse]
        def partition: () -> Types::Partition
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_partition-instance_method
      def get_partition: (
                           ?catalog_id: ::String,
                           database_name: ::String,
                           table_name: ::String,
                           partition_values: Array[::String]
                         ) -> _GetPartitionResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPartitionResponseSuccess

      interface _GetPartitionIndexesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPartitionIndexesResponse]
        def partition_index_descriptor_list: () -> ::Array[Types::PartitionIndexDescriptor]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_partition_indexes-instance_method
      def get_partition_indexes: (
                                   ?catalog_id: ::String,
                                   database_name: ::String,
                                   table_name: ::String,
                                   ?next_token: ::String
                                 ) -> _GetPartitionIndexesResponseSuccess
                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPartitionIndexesResponseSuccess

      interface _GetPartitionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPartitionsResponse]
        def partitions: () -> ::Array[Types::Partition]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_partitions-instance_method
      def get_partitions: (
                            ?catalog_id: ::String,
                            database_name: ::String,
                            table_name: ::String,
                            ?expression: ::String,
                            ?next_token: ::String,
                            ?segment: {
                              segment_number: ::Integer,
                              total_segments: ::Integer
                            },
                            ?max_results: ::Integer,
                            ?exclude_column_schema: bool,
                            ?transaction_id: ::String,
                            ?query_as_of_time: ::Time
                          ) -> _GetPartitionsResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPartitionsResponseSuccess

      interface _GetPlanResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetPlanResponse]
        def python_script: () -> ::String
        def scala_code: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_plan-instance_method
      def get_plan: (
                      mapping: Array[
                        {
                          source_table: ::String?,
                          source_path: ::String?,
                          source_type: ::String?,
                          target_table: ::String?,
                          target_path: ::String?,
                          target_type: ::String?
                        },
                      ],
                      source: {
                        database_name: ::String,
                        table_name: ::String
                      },
                      ?sinks: Array[
                        {
                          database_name: ::String,
                          table_name: ::String
                        },
                      ],
                      ?location: {
                        jdbc: Array[
                          {
                            name: ::String,
                            value: ::String,
                            param: bool?
                          },
                        ]?,
                        s3: Array[
                          {
                            name: ::String,
                            value: ::String,
                            param: bool?
                          },
                        ]?,
                        dynamo_db: Array[
                          {
                            name: ::String,
                            value: ::String,
                            param: bool?
                          },
                        ]?
                      },
                      ?language: ("PYTHON" | "SCALA"),
                      ?additional_plan_options_map: Hash[::String, ::String]
                    ) -> _GetPlanResponseSuccess
                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetPlanResponseSuccess

      interface _GetRegistryResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetRegistryResponse]
        def registry_name: () -> ::String
        def registry_arn: () -> ::String
        def description: () -> ::String
        def status: () -> ("AVAILABLE" | "DELETING")
        def created_time: () -> ::String
        def updated_time: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_registry-instance_method
      def get_registry: (
                          registry_id: {
                            registry_name: ::String?,
                            registry_arn: ::String?
                          }
                        ) -> _GetRegistryResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetRegistryResponseSuccess

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

      interface _GetResourcePolicyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetResourcePolicyResponse]
        def policy_in_json: () -> ::String
        def policy_hash: () -> ::String
        def create_time: () -> ::Time
        def update_time: () -> ::Time
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_resource_policy-instance_method
      def get_resource_policy: (
                                 ?resource_arn: ::String
                               ) -> _GetResourcePolicyResponseSuccess
                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetResourcePolicyResponseSuccess

      interface _GetSchemaResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetSchemaResponse]
        def registry_name: () -> ::String
        def registry_arn: () -> ::String
        def schema_name: () -> ::String
        def schema_arn: () -> ::String
        def description: () -> ::String
        def data_format: () -> ("AVRO" | "JSON" | "PROTOBUF")
        def compatibility: () -> ("NONE" | "DISABLED" | "BACKWARD" | "BACKWARD_ALL" | "FORWARD" | "FORWARD_ALL" | "FULL" | "FULL_ALL")
        def schema_checkpoint: () -> ::Integer
        def latest_schema_version: () -> ::Integer
        def next_schema_version: () -> ::Integer
        def schema_status: () -> ("AVAILABLE" | "PENDING" | "DELETING")
        def created_time: () -> ::String
        def updated_time: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_schema-instance_method
      def get_schema: (
                        schema_id: {
                          schema_arn: ::String?,
                          schema_name: ::String?,
                          registry_name: ::String?
                        }
                      ) -> _GetSchemaResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetSchemaResponseSuccess

      interface _GetSchemaByDefinitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetSchemaByDefinitionResponse]
        def schema_version_id: () -> ::String
        def schema_arn: () -> ::String
        def data_format: () -> ("AVRO" | "JSON" | "PROTOBUF")
        def status: () -> ("AVAILABLE" | "PENDING" | "FAILURE" | "DELETING")
        def created_time: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_schema_by_definition-instance_method
      def get_schema_by_definition: (
                                      schema_id: {
                                        schema_arn: ::String?,
                                        schema_name: ::String?,
                                        registry_name: ::String?
                                      },
                                      schema_definition: ::String
                                    ) -> _GetSchemaByDefinitionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetSchemaByDefinitionResponseSuccess

      interface _GetSchemaVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetSchemaVersionResponse]
        def schema_version_id: () -> ::String
        def schema_definition: () -> ::String
        def data_format: () -> ("AVRO" | "JSON" | "PROTOBUF")
        def schema_arn: () -> ::String
        def version_number: () -> ::Integer
        def status: () -> ("AVAILABLE" | "PENDING" | "FAILURE" | "DELETING")
        def created_time: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_schema_version-instance_method
      def get_schema_version: (
                                ?schema_id: {
                                  schema_arn: ::String?,
                                  schema_name: ::String?,
                                  registry_name: ::String?
                                },
                                ?schema_version_id: ::String,
                                ?schema_version_number: {
                                  latest_version: bool?,
                                  version_number: ::Integer?
                                }
                              ) -> _GetSchemaVersionResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetSchemaVersionResponseSuccess

      interface _GetSchemaVersionsDiffResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetSchemaVersionsDiffResponse]
        def diff: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_schema_versions_diff-instance_method
      def get_schema_versions_diff: (
                                      schema_id: {
                                        schema_arn: ::String?,
                                        schema_name: ::String?,
                                        registry_name: ::String?
                                      },
                                      first_schema_version_number: {
                                        latest_version: bool?,
                                        version_number: ::Integer?
                                      },
                                      second_schema_version_number: {
                                        latest_version: bool?,
                                        version_number: ::Integer?
                                      },
                                      schema_diff_type: ("SYNTAX_DIFF")
                                    ) -> _GetSchemaVersionsDiffResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetSchemaVersionsDiffResponseSuccess

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

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

      interface _GetSessionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetSessionResponse]
        def session: () -> Types::Session
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_session-instance_method
      def get_session: (
                         id: ::String,
                         ?request_origin: ::String
                       ) -> _GetSessionResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetSessionResponseSuccess

      interface _GetStatementResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetStatementResponse]
        def statement: () -> Types::Statement
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_statement-instance_method
      def get_statement: (
                           session_id: ::String,
                           id: ::Integer,
                           ?request_origin: ::String
                         ) -> _GetStatementResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetStatementResponseSuccess

      interface _GetTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTableResponse]
        def table: () -> Types::Table
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_table-instance_method
      def get_table: (
                       ?catalog_id: ::String,
                       database_name: ::String,
                       name: ::String,
                       ?transaction_id: ::String,
                       ?query_as_of_time: ::Time
                     ) -> _GetTableResponseSuccess
                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTableResponseSuccess

      interface _GetTableOptimizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTableOptimizerResponse]
        def catalog_id: () -> ::String
        def database_name: () -> ::String
        def table_name: () -> ::String
        def table_optimizer: () -> Types::TableOptimizer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_table_optimizer-instance_method
      def get_table_optimizer: (
                                 catalog_id: ::String,
                                 database_name: ::String,
                                 table_name: ::String,
                                 type: ("compaction")
                               ) -> _GetTableOptimizerResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTableOptimizerResponseSuccess

      interface _GetTableVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTableVersionResponse]
        def table_version: () -> Types::TableVersion
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_table_version-instance_method
      def get_table_version: (
                               ?catalog_id: ::String,
                               database_name: ::String,
                               table_name: ::String,
                               ?version_id: ::String
                             ) -> _GetTableVersionResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTableVersionResponseSuccess

      interface _GetTableVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTableVersionsResponse]
        def table_versions: () -> ::Array[Types::TableVersion]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_table_versions-instance_method
      def get_table_versions: (
                                ?catalog_id: ::String,
                                database_name: ::String,
                                table_name: ::String,
                                ?next_token: ::String,
                                ?max_results: ::Integer
                              ) -> _GetTableVersionsResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTableVersionsResponseSuccess

      interface _GetTablesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTablesResponse]
        def table_list: () -> ::Array[Types::Table]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_tables-instance_method
      def get_tables: (
                        ?catalog_id: ::String,
                        database_name: ::String,
                        ?expression: ::String,
                        ?next_token: ::String,
                        ?max_results: ::Integer,
                        ?transaction_id: ::String,
                        ?query_as_of_time: ::Time
                      ) -> _GetTablesResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTablesResponseSuccess

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

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

      interface _GetTriggersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetTriggersResponse]
        def triggers: () -> ::Array[Types::Trigger]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_triggers-instance_method
      def get_triggers: (
                          ?next_token: ::String,
                          ?dependent_job_name: ::String,
                          ?max_results: ::Integer
                        ) -> _GetTriggersResponseSuccess
                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetTriggersResponseSuccess

      interface _GetUnfilteredPartitionMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetUnfilteredPartitionMetadataResponse]
        def partition: () -> Types::Partition
        def authorized_columns: () -> ::Array[::String]
        def is_registered_with_lake_formation: () -> bool
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_unfiltered_partition_metadata-instance_method
      def get_unfiltered_partition_metadata: (
                                               ?region: ::String,
                                               catalog_id: ::String,
                                               database_name: ::String,
                                               table_name: ::String,
                                               partition_values: Array[::String],
                                               ?audit_context: {
                                                 additional_audit_context: ::String?,
                                                 requested_columns: Array[::String]?,
                                                 all_columns_requested: bool?
                                               },
                                               supported_permission_types: Array[("COLUMN_PERMISSION" | "CELL_FILTER_PERMISSION" | "NESTED_PERMISSION" | "NESTED_CELL_PERMISSION")],
                                               ?query_session_context: {
                                                 query_id: ::String?,
                                                 query_start_time: ::Time?,
                                                 cluster_id: ::String?,
                                                 query_authorization_id: ::String?,
                                                 additional_context: Hash[::String, ::String]?
                                               }
                                             ) -> _GetUnfilteredPartitionMetadataResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetUnfilteredPartitionMetadataResponseSuccess

      interface _GetUnfilteredPartitionsMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetUnfilteredPartitionsMetadataResponse]
        def unfiltered_partitions: () -> ::Array[Types::UnfilteredPartition]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_unfiltered_partitions_metadata-instance_method
      def get_unfiltered_partitions_metadata: (
                                                ?region: ::String,
                                                catalog_id: ::String,
                                                database_name: ::String,
                                                table_name: ::String,
                                                ?expression: ::String,
                                                ?audit_context: {
                                                  additional_audit_context: ::String?,
                                                  requested_columns: Array[::String]?,
                                                  all_columns_requested: bool?
                                                },
                                                supported_permission_types: Array[("COLUMN_PERMISSION" | "CELL_FILTER_PERMISSION" | "NESTED_PERMISSION" | "NESTED_CELL_PERMISSION")],
                                                ?next_token: ::String,
                                                ?segment: {
                                                  segment_number: ::Integer,
                                                  total_segments: ::Integer
                                                },
                                                ?max_results: ::Integer,
                                                ?query_session_context: {
                                                  query_id: ::String?,
                                                  query_start_time: ::Time?,
                                                  cluster_id: ::String?,
                                                  query_authorization_id: ::String?,
                                                  additional_context: Hash[::String, ::String]?
                                                }
                                              ) -> _GetUnfilteredPartitionsMetadataResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetUnfilteredPartitionsMetadataResponseSuccess

      interface _GetUnfilteredTableMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetUnfilteredTableMetadataResponse]
        def table: () -> Types::Table
        def authorized_columns: () -> ::Array[::String]
        def is_registered_with_lake_formation: () -> bool
        def cell_filters: () -> ::Array[Types::ColumnRowFilter]
        def query_authorization_id: () -> ::String
        def is_multi_dialect_view: () -> bool
        def resource_arn: () -> ::String
        def is_protected: () -> bool
        def permissions: () -> ::Array[("ALL" | "SELECT" | "ALTER" | "DROP" | "DELETE" | "INSERT" | "CREATE_DATABASE" | "CREATE_TABLE" | "DATA_LOCATION_ACCESS")]
        def row_filter: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_unfiltered_table_metadata-instance_method
      def get_unfiltered_table_metadata: (
                                           ?region: ::String,
                                           catalog_id: ::String,
                                           database_name: ::String,
                                           name: ::String,
                                           ?audit_context: {
                                             additional_audit_context: ::String?,
                                             requested_columns: Array[::String]?,
                                             all_columns_requested: bool?
                                           },
                                           supported_permission_types: Array[("COLUMN_PERMISSION" | "CELL_FILTER_PERMISSION" | "NESTED_PERMISSION" | "NESTED_CELL_PERMISSION")],
                                           ?parent_resource_arn: ::String,
                                           ?root_resource_arn: ::String,
                                           ?supported_dialect: {
                                             dialect: ("REDSHIFT" | "ATHENA" | "SPARK")?,
                                             dialect_version: ::String?
                                           },
                                           ?permissions: Array[("ALL" | "SELECT" | "ALTER" | "DROP" | "DELETE" | "INSERT" | "CREATE_DATABASE" | "CREATE_TABLE" | "DATA_LOCATION_ACCESS")],
                                           ?query_session_context: {
                                             query_id: ::String?,
                                             query_start_time: ::Time?,
                                             cluster_id: ::String?,
                                             query_authorization_id: ::String?,
                                             additional_context: Hash[::String, ::String]?
                                           }
                                         ) -> _GetUnfilteredTableMetadataResponseSuccess
                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetUnfilteredTableMetadataResponseSuccess

      interface _GetUserDefinedFunctionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetUserDefinedFunctionResponse]
        def user_defined_function: () -> Types::UserDefinedFunction
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_user_defined_function-instance_method
      def get_user_defined_function: (
                                       ?catalog_id: ::String,
                                       database_name: ::String,
                                       function_name: ::String
                                     ) -> _GetUserDefinedFunctionResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetUserDefinedFunctionResponseSuccess

      interface _GetUserDefinedFunctionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetUserDefinedFunctionsResponse]
        def user_defined_functions: () -> ::Array[Types::UserDefinedFunction]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_user_defined_functions-instance_method
      def get_user_defined_functions: (
                                        ?catalog_id: ::String,
                                        ?database_name: ::String,
                                        pattern: ::String,
                                        ?next_token: ::String,
                                        ?max_results: ::Integer
                                      ) -> _GetUserDefinedFunctionsResponseSuccess
                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetUserDefinedFunctionsResponseSuccess

      interface _GetWorkflowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetWorkflowResponse]
        def workflow: () -> Types::Workflow
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_workflow-instance_method
      def get_workflow: (
                          name: ::String,
                          ?include_graph: bool
                        ) -> _GetWorkflowResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetWorkflowResponseSuccess

      interface _GetWorkflowRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetWorkflowRunResponse]
        def run: () -> Types::WorkflowRun
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_workflow_run-instance_method
      def get_workflow_run: (
                              name: ::String,
                              run_id: ::String,
                              ?include_graph: bool
                            ) -> _GetWorkflowRunResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetWorkflowRunResponseSuccess

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

      interface _GetWorkflowRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::GetWorkflowRunsResponse]
        def runs: () -> ::Array[Types::WorkflowRun]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#get_workflow_runs-instance_method
      def get_workflow_runs: (
                               name: ::String,
                               ?include_graph: bool,
                               ?next_token: ::String,
                               ?max_results: ::Integer
                             ) -> _GetWorkflowRunsResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetWorkflowRunsResponseSuccess

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

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

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

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

      interface _ListCrawlsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCrawlsResponse]
        def crawls: () -> ::Array[Types::CrawlerHistory]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_crawls-instance_method
      def list_crawls: (
                         crawler_name: ::String,
                         ?max_results: ::Integer,
                         ?filters: Array[
                           {
                             field_name: ("CRAWL_ID" | "STATE" | "START_TIME" | "END_TIME" | "DPU_HOUR")?,
                             filter_operator: ("GT" | "GE" | "LT" | "LE" | "EQ" | "NE")?,
                             field_value: ::String?
                           },
                         ],
                         ?next_token: ::String
                       ) -> _ListCrawlsResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCrawlsResponseSuccess

      interface _ListCustomEntityTypesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListCustomEntityTypesResponse]
        def custom_entity_types: () -> ::Array[Types::CustomEntityType]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_custom_entity_types-instance_method
      def list_custom_entity_types: (
                                      ?next_token: ::String,
                                      ?max_results: ::Integer,
                                      ?tags: Hash[::String, ::String]
                                    ) -> _ListCustomEntityTypesResponseSuccess
                                  | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListCustomEntityTypesResponseSuccess

      interface _ListDataQualityResultsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDataQualityResultsResponse]
        def results: () -> ::Array[Types::DataQualityResultDescription]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_data_quality_results-instance_method
      def list_data_quality_results: (
                                       ?filter: {
                                         data_source: {
                                           glue_table: {
                                             database_name: ::String,
                                             table_name: ::String,
                                             catalog_id: ::String?,
                                             connection_name: ::String?,
                                             additional_options: Hash[::String, ::String]?
                                           }
                                         }?,
                                         job_name: ::String?,
                                         job_run_id: ::String?,
                                         started_after: ::Time?,
                                         started_before: ::Time?
                                       },
                                       ?next_token: ::String,
                                       ?max_results: ::Integer
                                     ) -> _ListDataQualityResultsResponseSuccess
                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDataQualityResultsResponseSuccess

      interface _ListDataQualityRuleRecommendationRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDataQualityRuleRecommendationRunsResponse]
        def runs: () -> ::Array[Types::DataQualityRuleRecommendationRunDescription]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_data_quality_rule_recommendation_runs-instance_method
      def list_data_quality_rule_recommendation_runs: (
                                                        ?filter: {
                                                          data_source: {
                                                            glue_table: {
                                                              database_name: ::String,
                                                              table_name: ::String,
                                                              catalog_id: ::String?,
                                                              connection_name: ::String?,
                                                              additional_options: Hash[::String, ::String]?
                                                            }
                                                          },
                                                          started_before: ::Time?,
                                                          started_after: ::Time?
                                                        },
                                                        ?next_token: ::String,
                                                        ?max_results: ::Integer
                                                      ) -> _ListDataQualityRuleRecommendationRunsResponseSuccess
                                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDataQualityRuleRecommendationRunsResponseSuccess

      interface _ListDataQualityRulesetEvaluationRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDataQualityRulesetEvaluationRunsResponse]
        def runs: () -> ::Array[Types::DataQualityRulesetEvaluationRunDescription]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_data_quality_ruleset_evaluation_runs-instance_method
      def list_data_quality_ruleset_evaluation_runs: (
                                                       ?filter: {
                                                         data_source: {
                                                           glue_table: {
                                                             database_name: ::String,
                                                             table_name: ::String,
                                                             catalog_id: ::String?,
                                                             connection_name: ::String?,
                                                             additional_options: Hash[::String, ::String]?
                                                           }
                                                         },
                                                         started_before: ::Time?,
                                                         started_after: ::Time?
                                                       },
                                                       ?next_token: ::String,
                                                       ?max_results: ::Integer
                                                     ) -> _ListDataQualityRulesetEvaluationRunsResponseSuccess
                                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDataQualityRulesetEvaluationRunsResponseSuccess

      interface _ListDataQualityRulesetsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListDataQualityRulesetsResponse]
        def rulesets: () -> ::Array[Types::DataQualityRulesetListDetails]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_data_quality_rulesets-instance_method
      def list_data_quality_rulesets: (
                                        ?next_token: ::String,
                                        ?max_results: ::Integer,
                                        ?filter: {
                                          name: ::String?,
                                          description: ::String?,
                                          created_before: ::Time?,
                                          created_after: ::Time?,
                                          last_modified_before: ::Time?,
                                          last_modified_after: ::Time?,
                                          target_table: {
                                            table_name: ::String,
                                            database_name: ::String,
                                            catalog_id: ::String?
                                          }?
                                        },
                                        ?tags: Hash[::String, ::String]
                                      ) -> _ListDataQualityRulesetsResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDataQualityRulesetsResponseSuccess

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

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

      interface _ListMLTransformsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListMLTransformsResponse]
        def transform_ids: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_ml_transforms-instance_method
      def list_ml_transforms: (
                                ?next_token: ::String,
                                ?max_results: ::Integer,
                                ?filter: {
                                  name: ::String?,
                                  transform_type: ("FIND_MATCHES")?,
                                  status: ("NOT_READY" | "READY" | "DELETING")?,
                                  glue_version: ::String?,
                                  created_before: ::Time?,
                                  created_after: ::Time?,
                                  last_modified_before: ::Time?,
                                  last_modified_after: ::Time?,
                                  schema: Array[
                                    {
                                      name: ::String?,
                                      data_type: ::String?
                                    },
                                  ]?
                                },
                                ?sort: {
                                  column: ("NAME" | "TRANSFORM_TYPE" | "STATUS" | "CREATED" | "LAST_MODIFIED"),
                                  sort_direction: ("DESCENDING" | "ASCENDING")
                                },
                                ?tags: Hash[::String, ::String]
                              ) -> _ListMLTransformsResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListMLTransformsResponseSuccess

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

      interface _ListSchemaVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSchemaVersionsResponse]
        def schemas: () -> ::Array[Types::SchemaVersionListItem]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_schema_versions-instance_method
      def list_schema_versions: (
                                  schema_id: {
                                    schema_arn: ::String?,
                                    schema_name: ::String?,
                                    registry_name: ::String?
                                  },
                                  ?max_results: ::Integer,
                                  ?next_token: ::String
                                ) -> _ListSchemaVersionsResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSchemaVersionsResponseSuccess

      interface _ListSchemasResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSchemasResponse]
        def schemas: () -> ::Array[Types::SchemaListItem]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_schemas-instance_method
      def list_schemas: (
                          ?registry_id: {
                            registry_name: ::String?,
                            registry_arn: ::String?
                          },
                          ?max_results: ::Integer,
                          ?next_token: ::String
                        ) -> _ListSchemasResponseSuccess
                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSchemasResponseSuccess

      interface _ListSessionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListSessionsResponse]
        def ids: () -> ::Array[::String]
        def sessions: () -> ::Array[Types::Session]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_sessions-instance_method
      def list_sessions: (
                           ?next_token: ::String,
                           ?max_results: ::Integer,
                           ?tags: Hash[::String, ::String],
                           ?request_origin: ::String
                         ) -> _ListSessionsResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListSessionsResponseSuccess

      interface _ListStatementsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListStatementsResponse]
        def statements: () -> ::Array[Types::Statement]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_statements-instance_method
      def list_statements: (
                             session_id: ::String,
                             ?request_origin: ::String,
                             ?next_token: ::String
                           ) -> _ListStatementsResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListStatementsResponseSuccess

      interface _ListTableOptimizerRunsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTableOptimizerRunsResponse]
        def catalog_id: () -> ::String
        def database_name: () -> ::String
        def table_name: () -> ::String
        def next_token: () -> ::String
        def table_optimizer_runs: () -> ::Array[Types::TableOptimizerRun]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_table_optimizer_runs-instance_method
      def list_table_optimizer_runs: (
                                       catalog_id: ::String,
                                       database_name: ::String,
                                       table_name: ::String,
                                       type: ("compaction"),
                                       ?max_results: ::Integer,
                                       ?next_token: ::String
                                     ) -> _ListTableOptimizerRunsResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTableOptimizerRunsResponseSuccess

      interface _ListTriggersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ListTriggersResponse]
        def trigger_names: () -> ::Array[::String]
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#list_triggers-instance_method
      def list_triggers: (
                           ?next_token: ::String,
                           ?dependent_job_name: ::String,
                           ?max_results: ::Integer,
                           ?tags: Hash[::String, ::String]
                         ) -> _ListTriggersResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTriggersResponseSuccess

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

      interface _PutDataCatalogEncryptionSettingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PutDataCatalogEncryptionSettingsResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#put_data_catalog_encryption_settings-instance_method
      def put_data_catalog_encryption_settings: (
                                                  ?catalog_id: ::String,
                                                  data_catalog_encryption_settings: {
                                                    encryption_at_rest: {
                                                      catalog_encryption_mode: ("DISABLED" | "SSE-KMS" | "SSE-KMS-WITH-SERVICE-ROLE"),
                                                      sse_aws_kms_key_id: ::String?,
                                                      catalog_encryption_service_role: ::String?
                                                    }?,
                                                    connection_password_encryption: {
                                                      return_connection_password_encrypted: bool,
                                                      aws_kms_key_id: ::String?
                                                    }?
                                                  }
                                                ) -> _PutDataCatalogEncryptionSettingsResponseSuccess
                                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutDataCatalogEncryptionSettingsResponseSuccess

      interface _PutResourcePolicyResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PutResourcePolicyResponse]
        def policy_hash: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#put_resource_policy-instance_method
      def put_resource_policy: (
                                 policy_in_json: ::String,
                                 ?resource_arn: ::String,
                                 ?policy_hash_condition: ::String,
                                 ?policy_exists_condition: ("MUST_EXIST" | "NOT_EXIST" | "NONE"),
                                 ?enable_hybrid: ("TRUE" | "FALSE")
                               ) -> _PutResourcePolicyResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutResourcePolicyResponseSuccess

      interface _PutSchemaVersionMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PutSchemaVersionMetadataResponse]
        def schema_arn: () -> ::String
        def schema_name: () -> ::String
        def registry_name: () -> ::String
        def latest_version: () -> bool
        def version_number: () -> ::Integer
        def schema_version_id: () -> ::String
        def metadata_key: () -> ::String
        def metadata_value: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#put_schema_version_metadata-instance_method
      def put_schema_version_metadata: (
                                         ?schema_id: {
                                           schema_arn: ::String?,
                                           schema_name: ::String?,
                                           registry_name: ::String?
                                         },
                                         ?schema_version_number: {
                                           latest_version: bool?,
                                           version_number: ::Integer?
                                         },
                                         ?schema_version_id: ::String,
                                         metadata_key_value: {
                                           metadata_key: ::String?,
                                           metadata_value: ::String?
                                         }
                                       ) -> _PutSchemaVersionMetadataResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutSchemaVersionMetadataResponseSuccess

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

      interface _QuerySchemaVersionMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::QuerySchemaVersionMetadataResponse]
        def metadata_info_map: () -> ::Hash[::String, Types::MetadataInfo]
        def schema_version_id: () -> ::String
        def next_token: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#query_schema_version_metadata-instance_method
      def query_schema_version_metadata: (
                                           ?schema_id: {
                                             schema_arn: ::String?,
                                             schema_name: ::String?,
                                             registry_name: ::String?
                                           },
                                           ?schema_version_number: {
                                             latest_version: bool?,
                                             version_number: ::Integer?
                                           },
                                           ?schema_version_id: ::String,
                                           ?metadata_list: Array[
                                             {
                                               metadata_key: ::String?,
                                               metadata_value: ::String?
                                             },
                                           ],
                                           ?max_results: ::Integer,
                                           ?next_token: ::String
                                         ) -> _QuerySchemaVersionMetadataResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _QuerySchemaVersionMetadataResponseSuccess

      interface _RegisterSchemaVersionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RegisterSchemaVersionResponse]
        def schema_version_id: () -> ::String
        def version_number: () -> ::Integer
        def status: () -> ("AVAILABLE" | "PENDING" | "FAILURE" | "DELETING")
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#register_schema_version-instance_method
      def register_schema_version: (
                                     schema_id: {
                                       schema_arn: ::String?,
                                       schema_name: ::String?,
                                       registry_name: ::String?
                                     },
                                     schema_definition: ::String
                                   ) -> _RegisterSchemaVersionResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterSchemaVersionResponseSuccess

      interface _RemoveSchemaVersionMetadataResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RemoveSchemaVersionMetadataResponse]
        def schema_arn: () -> ::String
        def schema_name: () -> ::String
        def registry_name: () -> ::String
        def latest_version: () -> bool
        def version_number: () -> ::Integer
        def schema_version_id: () -> ::String
        def metadata_key: () -> ::String
        def metadata_value: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#remove_schema_version_metadata-instance_method
      def remove_schema_version_metadata: (
                                            ?schema_id: {
                                              schema_arn: ::String?,
                                              schema_name: ::String?,
                                              registry_name: ::String?
                                            },
                                            ?schema_version_number: {
                                              latest_version: bool?,
                                              version_number: ::Integer?
                                            },
                                            ?schema_version_id: ::String,
                                            metadata_key_value: {
                                              metadata_key: ::String?,
                                              metadata_value: ::String?
                                            }
                                          ) -> _RemoveSchemaVersionMetadataResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RemoveSchemaVersionMetadataResponseSuccess

      interface _ResetJobBookmarkResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ResetJobBookmarkResponse]
        def job_bookmark_entry: () -> Types::JobBookmarkEntry
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#reset_job_bookmark-instance_method
      def reset_job_bookmark: (
                                job_name: ::String,
                                ?run_id: ::String
                              ) -> _ResetJobBookmarkResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ResetJobBookmarkResponseSuccess

      interface _ResumeWorkflowRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ResumeWorkflowRunResponse]
        def run_id: () -> ::String
        def node_ids: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#resume_workflow_run-instance_method
      def resume_workflow_run: (
                                 name: ::String,
                                 run_id: ::String,
                                 node_ids: Array[::String]
                               ) -> _ResumeWorkflowRunResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ResumeWorkflowRunResponseSuccess

      interface _RunStatementResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RunStatementResponse]
        def id: () -> ::Integer
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#run_statement-instance_method
      def run_statement: (
                           session_id: ::String,
                           code: ::String,
                           ?request_origin: ::String
                         ) -> _RunStatementResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RunStatementResponseSuccess

      interface _SearchTablesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::SearchTablesResponse]
        def next_token: () -> ::String
        def table_list: () -> ::Array[Types::Table]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#search_tables-instance_method
      def search_tables: (
                           ?catalog_id: ::String,
                           ?next_token: ::String,
                           ?filters: Array[
                             {
                               key: ::String?,
                               value: ::String?,
                               comparator: ("EQUALS" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_EQUALS" | "LESS_THAN_EQUALS")?
                             },
                           ],
                           ?search_text: ::String,
                           ?sort_criteria: Array[
                             {
                               field_name: ::String?,
                               sort: ("ASC" | "DESC")?
                             },
                           ],
                           ?max_results: ::Integer,
                           ?resource_share_type: ("FOREIGN" | "ALL" | "FEDERATED")
                         ) -> _SearchTablesResponseSuccess
                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SearchTablesResponseSuccess

      interface _StartBlueprintRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartBlueprintRunResponse]
        def run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_blueprint_run-instance_method
      def start_blueprint_run: (
                                 blueprint_name: ::String,
                                 ?parameters: ::String,
                                 role_arn: ::String
                               ) -> _StartBlueprintRunResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartBlueprintRunResponseSuccess

      interface _StartColumnStatisticsTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartColumnStatisticsTaskRunResponse]
        def column_statistics_task_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_column_statistics_task_run-instance_method
      def start_column_statistics_task_run: (
                                              database_name: ::String,
                                              table_name: ::String,
                                              ?column_name_list: Array[::String],
                                              role: ::String,
                                              ?sample_size: ::Float,
                                              ?catalog_id: ::String,
                                              ?security_configuration: ::String
                                            ) -> _StartColumnStatisticsTaskRunResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartColumnStatisticsTaskRunResponseSuccess

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

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

      interface _StartDataQualityRuleRecommendationRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartDataQualityRuleRecommendationRunResponse]
        def run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_data_quality_rule_recommendation_run-instance_method
      def start_data_quality_rule_recommendation_run: (
                                                        data_source: {
                                                          glue_table: {
                                                            database_name: ::String,
                                                            table_name: ::String,
                                                            catalog_id: ::String?,
                                                            connection_name: ::String?,
                                                            additional_options: Hash[::String, ::String]?
                                                          }
                                                        },
                                                        role: ::String,
                                                        ?number_of_workers: ::Integer,
                                                        ?timeout: ::Integer,
                                                        ?created_ruleset_name: ::String,
                                                        ?client_token: ::String
                                                      ) -> _StartDataQualityRuleRecommendationRunResponseSuccess
                                                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartDataQualityRuleRecommendationRunResponseSuccess

      interface _StartDataQualityRulesetEvaluationRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartDataQualityRulesetEvaluationRunResponse]
        def run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_data_quality_ruleset_evaluation_run-instance_method
      def start_data_quality_ruleset_evaluation_run: (
                                                       data_source: {
                                                         glue_table: {
                                                           database_name: ::String,
                                                           table_name: ::String,
                                                           catalog_id: ::String?,
                                                           connection_name: ::String?,
                                                           additional_options: Hash[::String, ::String]?
                                                         }
                                                       },
                                                       role: ::String,
                                                       ?number_of_workers: ::Integer,
                                                       ?timeout: ::Integer,
                                                       ?client_token: ::String,
                                                       ?additional_run_options: {
                                                         cloud_watch_metrics_enabled: bool?,
                                                         results_s3_prefix: ::String?
                                                       },
                                                       ruleset_names: Array[::String],
                                                       ?additional_data_sources: Hash[::String, {
                                                           glue_table: {
                                                             database_name: ::String,
                                                             table_name: ::String,
                                                             catalog_id: ::String?,
                                                             connection_name: ::String?,
                                                             additional_options: Hash[::String, ::String]?
                                                           }
                                                         }]
                                                     ) -> _StartDataQualityRulesetEvaluationRunResponseSuccess
                                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartDataQualityRulesetEvaluationRunResponseSuccess

      interface _StartExportLabelsTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartExportLabelsTaskRunResponse]
        def task_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_export_labels_task_run-instance_method
      def start_export_labels_task_run: (
                                          transform_id: ::String,
                                          output_s3_path: ::String
                                        ) -> _StartExportLabelsTaskRunResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartExportLabelsTaskRunResponseSuccess

      interface _StartImportLabelsTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartImportLabelsTaskRunResponse]
        def task_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_import_labels_task_run-instance_method
      def start_import_labels_task_run: (
                                          transform_id: ::String,
                                          input_s3_path: ::String,
                                          ?replace_all_labels: bool
                                        ) -> _StartImportLabelsTaskRunResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartImportLabelsTaskRunResponseSuccess

      interface _StartJobRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartJobRunResponse]
        def job_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_job_run-instance_method
      def start_job_run: (
                           job_name: ::String,
                           ?job_run_id: ::String,
                           ?arguments: Hash[::String, ::String],
                           ?allocated_capacity: ::Integer,
                           ?timeout: ::Integer,
                           ?max_capacity: ::Float,
                           ?security_configuration: ::String,
                           ?notification_property: {
                             notify_delay_after: ::Integer?
                           },
                           ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                           ?number_of_workers: ::Integer,
                           ?execution_class: ("FLEX" | "STANDARD")
                         ) -> _StartJobRunResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartJobRunResponseSuccess

      interface _StartMLEvaluationTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartMLEvaluationTaskRunResponse]
        def task_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_ml_evaluation_task_run-instance_method
      def start_ml_evaluation_task_run: (
                                          transform_id: ::String
                                        ) -> _StartMLEvaluationTaskRunResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartMLEvaluationTaskRunResponseSuccess

      interface _StartMLLabelingSetGenerationTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartMLLabelingSetGenerationTaskRunResponse]
        def task_run_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#start_ml_labeling_set_generation_task_run-instance_method
      def start_ml_labeling_set_generation_task_run: (
                                                       transform_id: ::String,
                                                       output_s3_path: ::String
                                                     ) -> _StartMLLabelingSetGenerationTaskRunResponseSuccess
                                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartMLLabelingSetGenerationTaskRunResponseSuccess

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

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

      interface _StopColumnStatisticsTaskRunResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StopColumnStatisticsTaskRunResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#stop_column_statistics_task_run-instance_method
      def stop_column_statistics_task_run: (
                                             database_name: ::String,
                                             table_name: ::String
                                           ) -> _StopColumnStatisticsTaskRunResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StopColumnStatisticsTaskRunResponseSuccess

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

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

      interface _StopSessionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StopSessionResponse]
        def id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#stop_session-instance_method
      def stop_session: (
                          id: ::String,
                          ?request_origin: ::String
                        ) -> _StopSessionResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StopSessionResponseSuccess

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

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

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

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

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

      interface _UpdateClassifierResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateClassifierResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_classifier-instance_method
      def update_classifier: (
                               ?grok_classifier: {
                                 name: ::String,
                                 classification: ::String?,
                                 grok_pattern: ::String?,
                                 custom_patterns: ::String?
                               },
                               ?xml_classifier: {
                                 name: ::String,
                                 classification: ::String?,
                                 row_tag: ::String?
                               },
                               ?json_classifier: {
                                 name: ::String,
                                 json_path: ::String?
                               },
                               ?csv_classifier: {
                                 name: ::String,
                                 delimiter: ::String?,
                                 quote_symbol: ::String?,
                                 contains_header: ("UNKNOWN" | "PRESENT" | "ABSENT")?,
                                 header: Array[::String]?,
                                 disable_value_trimming: bool?,
                                 allow_single_column: bool?,
                                 custom_datatype_configured: bool?,
                                 custom_datatypes: Array[::String]?,
                                 serde: ("OpenCSVSerDe" | "LazySimpleSerDe" | "None")?
                               }
                             ) -> _UpdateClassifierResponseSuccess
                           | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateClassifierResponseSuccess

      interface _UpdateColumnStatisticsForPartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateColumnStatisticsForPartitionResponse]
        def errors: () -> ::Array[Types::ColumnStatisticsError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_column_statistics_for_partition-instance_method
      def update_column_statistics_for_partition: (
                                                    ?catalog_id: ::String,
                                                    database_name: ::String,
                                                    table_name: ::String,
                                                    partition_values: Array[::String],
                                                    column_statistics_list: Array[
                                                      {
                                                        column_name: ::String,
                                                        column_type: ::String,
                                                        analyzed_time: ::Time,
                                                        statistics_data: {
                                                          type: ("BOOLEAN" | "DATE" | "DECIMAL" | "DOUBLE" | "LONG" | "STRING" | "BINARY"),
                                                          boolean_column_statistics_data: {
                                                            number_of_trues: ::Integer,
                                                            number_of_falses: ::Integer,
                                                            number_of_nulls: ::Integer
                                                          }?,
                                                          date_column_statistics_data: {
                                                            minimum_value: ::Time?,
                                                            maximum_value: ::Time?,
                                                            number_of_nulls: ::Integer,
                                                            number_of_distinct_values: ::Integer
                                                          }?,
                                                          decimal_column_statistics_data: {
                                                            minimum_value: {
                                                              unscaled_value: ::String,
                                                              scale: ::Integer
                                                            }?,
                                                            maximum_value: {
                                                              unscaled_value: ::String,
                                                              scale: ::Integer
                                                            }?,
                                                            number_of_nulls: ::Integer,
                                                            number_of_distinct_values: ::Integer
                                                          }?,
                                                          double_column_statistics_data: {
                                                            minimum_value: ::Float?,
                                                            maximum_value: ::Float?,
                                                            number_of_nulls: ::Integer,
                                                            number_of_distinct_values: ::Integer
                                                          }?,
                                                          long_column_statistics_data: {
                                                            minimum_value: ::Integer?,
                                                            maximum_value: ::Integer?,
                                                            number_of_nulls: ::Integer,
                                                            number_of_distinct_values: ::Integer
                                                          }?,
                                                          string_column_statistics_data: {
                                                            maximum_length: ::Integer,
                                                            average_length: ::Float,
                                                            number_of_nulls: ::Integer,
                                                            number_of_distinct_values: ::Integer
                                                          }?,
                                                          binary_column_statistics_data: {
                                                            maximum_length: ::Integer,
                                                            average_length: ::Float,
                                                            number_of_nulls: ::Integer
                                                          }?
                                                        }
                                                      },
                                                    ]
                                                  ) -> _UpdateColumnStatisticsForPartitionResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateColumnStatisticsForPartitionResponseSuccess

      interface _UpdateColumnStatisticsForTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateColumnStatisticsForTableResponse]
        def errors: () -> ::Array[Types::ColumnStatisticsError]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_column_statistics_for_table-instance_method
      def update_column_statistics_for_table: (
                                                ?catalog_id: ::String,
                                                database_name: ::String,
                                                table_name: ::String,
                                                column_statistics_list: Array[
                                                  {
                                                    column_name: ::String,
                                                    column_type: ::String,
                                                    analyzed_time: ::Time,
                                                    statistics_data: {
                                                      type: ("BOOLEAN" | "DATE" | "DECIMAL" | "DOUBLE" | "LONG" | "STRING" | "BINARY"),
                                                      boolean_column_statistics_data: {
                                                        number_of_trues: ::Integer,
                                                        number_of_falses: ::Integer,
                                                        number_of_nulls: ::Integer
                                                      }?,
                                                      date_column_statistics_data: {
                                                        minimum_value: ::Time?,
                                                        maximum_value: ::Time?,
                                                        number_of_nulls: ::Integer,
                                                        number_of_distinct_values: ::Integer
                                                      }?,
                                                      decimal_column_statistics_data: {
                                                        minimum_value: {
                                                          unscaled_value: ::String,
                                                          scale: ::Integer
                                                        }?,
                                                        maximum_value: {
                                                          unscaled_value: ::String,
                                                          scale: ::Integer
                                                        }?,
                                                        number_of_nulls: ::Integer,
                                                        number_of_distinct_values: ::Integer
                                                      }?,
                                                      double_column_statistics_data: {
                                                        minimum_value: ::Float?,
                                                        maximum_value: ::Float?,
                                                        number_of_nulls: ::Integer,
                                                        number_of_distinct_values: ::Integer
                                                      }?,
                                                      long_column_statistics_data: {
                                                        minimum_value: ::Integer?,
                                                        maximum_value: ::Integer?,
                                                        number_of_nulls: ::Integer,
                                                        number_of_distinct_values: ::Integer
                                                      }?,
                                                      string_column_statistics_data: {
                                                        maximum_length: ::Integer,
                                                        average_length: ::Float,
                                                        number_of_nulls: ::Integer,
                                                        number_of_distinct_values: ::Integer
                                                      }?,
                                                      binary_column_statistics_data: {
                                                        maximum_length: ::Integer,
                                                        average_length: ::Float,
                                                        number_of_nulls: ::Integer
                                                      }?
                                                    }
                                                  },
                                                ]
                                              ) -> _UpdateColumnStatisticsForTableResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateColumnStatisticsForTableResponseSuccess

      interface _UpdateConnectionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateConnectionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_connection-instance_method
      def update_connection: (
                               ?catalog_id: ::String,
                               name: ::String,
                               connection_input: {
                                 name: ::String,
                                 description: ::String?,
                                 connection_type: ("JDBC" | "SFTP" | "MONGODB" | "KAFKA" | "NETWORK" | "MARKETPLACE" | "CUSTOM" | "SALESFORCE"),
                                 match_criteria: Array[::String]?,
                                 connection_properties: Hash[("HOST" | "PORT" | "USERNAME" | "PASSWORD" | "ENCRYPTED_PASSWORD" | "JDBC_DRIVER_JAR_URI" | "JDBC_DRIVER_CLASS_NAME" | "JDBC_ENGINE" | "JDBC_ENGINE_VERSION" | "CONFIG_FILES" | "INSTANCE_ID" | "JDBC_CONNECTION_URL" | "JDBC_ENFORCE_SSL" | "CUSTOM_JDBC_CERT" | "SKIP_CUSTOM_JDBC_CERT_VALIDATION" | "CUSTOM_JDBC_CERT_STRING" | "CONNECTION_URL" | "KAFKA_BOOTSTRAP_SERVERS" | "KAFKA_SSL_ENABLED" | "KAFKA_CUSTOM_CERT" | "KAFKA_SKIP_CUSTOM_CERT_VALIDATION" | "KAFKA_CLIENT_KEYSTORE" | "KAFKA_CLIENT_KEYSTORE_PASSWORD" | "KAFKA_CLIENT_KEY_PASSWORD" | "ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD" | "ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD" | "SECRET_ID" | "CONNECTOR_URL" | "CONNECTOR_TYPE" | "CONNECTOR_CLASS_NAME" | "KAFKA_SASL_MECHANISM" | "KAFKA_SASL_PLAIN_USERNAME" | "KAFKA_SASL_PLAIN_PASSWORD" | "ENCRYPTED_KAFKA_SASL_PLAIN_PASSWORD" | "KAFKA_SASL_SCRAM_USERNAME" | "KAFKA_SASL_SCRAM_PASSWORD" | "KAFKA_SASL_SCRAM_SECRETS_ARN" | "ENCRYPTED_KAFKA_SASL_SCRAM_PASSWORD" | "KAFKA_SASL_GSSAPI_KEYTAB" | "KAFKA_SASL_GSSAPI_KRB5_CONF" | "KAFKA_SASL_GSSAPI_SERVICE" | "KAFKA_SASL_GSSAPI_PRINCIPAL" | "ROLE_ARN"), ::String],
                                 physical_connection_requirements: {
                                   subnet_id: ::String?,
                                   security_group_id_list: Array[::String]?,
                                   availability_zone: ::String?
                                 }?,
                                 authentication_configuration: {
                                   authentication_type: ("BASIC" | "OAUTH2" | "CUSTOM")?,
                                   secret_arn: ::String?,
                                   o_auth_2_properties: {
                                     o_auth_2_grant_type: ("AUTHORIZATION_CODE" | "CLIENT_CREDENTIALS" | "JWT_BEARER")?,
                                     o_auth_2_client_application: {
                                       user_managed_client_application_client_id: ::String?,
                                       aws_managed_client_application_reference: ::String?
                                     }?,
                                     token_url: ::String?,
                                     token_url_parameters_map: Hash[::String, ::String]?,
                                     authorization_code_properties: {
                                       authorization_code: ::String?,
                                       redirect_uri: ::String?
                                     }?
                                   }?
                                 }?,
                                 validate_credentials: bool?
                               }
                             ) -> _UpdateConnectionResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateConnectionResponseSuccess

      interface _UpdateCrawlerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateCrawlerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_crawler-instance_method
      def update_crawler: (
                            name: ::String,
                            ?role: ::String,
                            ?database_name: ::String,
                            ?description: ::String,
                            ?targets: {
                              s3_targets: Array[
                                {
                                  path: ::String?,
                                  exclusions: Array[::String]?,
                                  connection_name: ::String?,
                                  sample_size: ::Integer?,
                                  event_queue_arn: ::String?,
                                  dlq_event_queue_arn: ::String?
                                },
                              ]?,
                              jdbc_targets: Array[
                                {
                                  connection_name: ::String?,
                                  path: ::String?,
                                  exclusions: Array[::String]?,
                                  enable_additional_metadata: Array[("COMMENTS" | "RAWTYPES")]?
                                },
                              ]?,
                              mongo_db_targets: Array[
                                {
                                  connection_name: ::String?,
                                  path: ::String?,
                                  scan_all: bool?
                                },
                              ]?,
                              dynamo_db_targets: Array[
                                {
                                  path: ::String?,
                                  scan_all: bool?,
                                  scan_rate: ::Float?
                                },
                              ]?,
                              catalog_targets: Array[
                                {
                                  database_name: ::String,
                                  tables: Array[::String],
                                  connection_name: ::String?,
                                  event_queue_arn: ::String?,
                                  dlq_event_queue_arn: ::String?
                                },
                              ]?,
                              delta_targets: Array[
                                {
                                  delta_tables: Array[::String]?,
                                  connection_name: ::String?,
                                  write_manifest: bool?,
                                  create_native_delta_table: bool?
                                },
                              ]?,
                              iceberg_targets: Array[
                                {
                                  paths: Array[::String]?,
                                  connection_name: ::String?,
                                  exclusions: Array[::String]?,
                                  maximum_traversal_depth: ::Integer?
                                },
                              ]?,
                              hudi_targets: Array[
                                {
                                  paths: Array[::String]?,
                                  connection_name: ::String?,
                                  exclusions: Array[::String]?,
                                  maximum_traversal_depth: ::Integer?
                                },
                              ]?
                            },
                            ?schedule: ::String,
                            ?classifiers: Array[::String],
                            ?table_prefix: ::String,
                            ?schema_change_policy: {
                              update_behavior: ("LOG" | "UPDATE_IN_DATABASE")?,
                              delete_behavior: ("LOG" | "DELETE_FROM_DATABASE" | "DEPRECATE_IN_DATABASE")?
                            },
                            ?recrawl_policy: {
                              recrawl_behavior: ("CRAWL_EVERYTHING" | "CRAWL_NEW_FOLDERS_ONLY" | "CRAWL_EVENT_MODE")?
                            },
                            ?lineage_configuration: {
                              crawler_lineage_settings: ("ENABLE" | "DISABLE")?
                            },
                            ?lake_formation_configuration: {
                              use_lake_formation_credentials: bool?,
                              account_id: ::String?
                            },
                            ?configuration: ::String,
                            ?crawler_security_configuration: ::String
                          ) -> _UpdateCrawlerResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateCrawlerResponseSuccess

      interface _UpdateCrawlerScheduleResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateCrawlerScheduleResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_crawler_schedule-instance_method
      def update_crawler_schedule: (
                                     crawler_name: ::String,
                                     ?schedule: ::String
                                   ) -> _UpdateCrawlerScheduleResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateCrawlerScheduleResponseSuccess

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

      interface _UpdateDatabaseResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDatabaseResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_database-instance_method
      def update_database: (
                             ?catalog_id: ::String,
                             name: ::String,
                             database_input: {
                               name: ::String,
                               description: ::String?,
                               location_uri: ::String?,
                               parameters: Hash[::String, ::String]?,
                               create_table_default_permissions: Array[
                                 {
                                   principal: {
                                     data_lake_principal_identifier: ::String?
                                   }?,
                                   permissions: Array[("ALL" | "SELECT" | "ALTER" | "DROP" | "DELETE" | "INSERT" | "CREATE_DATABASE" | "CREATE_TABLE" | "DATA_LOCATION_ACCESS")]?
                                 },
                               ]?,
                               target_database: {
                                 catalog_id: ::String?,
                                 database_name: ::String?,
                                 region: ::String?
                               }?,
                               federated_database: {
                                 identifier: ::String?,
                                 connection_name: ::String?
                               }?
                             }
                           ) -> _UpdateDatabaseResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDatabaseResponseSuccess

      interface _UpdateDevEndpointResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDevEndpointResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_dev_endpoint-instance_method
      def update_dev_endpoint: (
                                 endpoint_name: ::String,
                                 ?public_key: ::String,
                                 ?add_public_keys: Array[::String],
                                 ?delete_public_keys: Array[::String],
                                 ?custom_libraries: {
                                   extra_python_libs_s3_path: ::String?,
                                   extra_jars_s3_path: ::String?
                                 },
                                 ?update_etl_libraries: bool,
                                 ?delete_arguments: Array[::String],
                                 ?add_arguments: Hash[::String, ::String]
                               ) -> _UpdateDevEndpointResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDevEndpointResponseSuccess

      interface _UpdateJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateJobResponse]
        def job_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_job-instance_method
      def update_job: (
                        job_name: ::String,
                        job_update: {
                          job_mode: ("SCRIPT" | "VISUAL" | "NOTEBOOK")?,
                          description: ::String?,
                          log_uri: ::String?,
                          role: ::String?,
                          execution_property: {
                            max_concurrent_runs: ::Integer?
                          }?,
                          command: {
                            name: ::String?,
                            script_location: ::String?,
                            python_version: ::String?,
                            runtime: ::String?
                          }?,
                          default_arguments: Hash[::String, ::String]?,
                          non_overridable_arguments: Hash[::String, ::String]?,
                          connections: {
                            connections: Array[::String]?
                          }?,
                          max_retries: ::Integer?,
                          allocated_capacity: ::Integer?,
                          timeout: ::Integer?,
                          max_capacity: ::Float?,
                          worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X")?,
                          number_of_workers: ::Integer?,
                          security_configuration: ::String?,
                          notification_property: {
                            notify_delay_after: ::Integer?
                          }?,
                          glue_version: ::String?,
                          code_gen_configuration_nodes: Hash[::String, {
                              athena_connector_source: {
                                name: ::String,
                                connection_name: ::String,
                                connector_name: ::String,
                                connection_type: ::String,
                                connection_table: ::String?,
                                schema_name: ::String,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              jdbc_connector_source: {
                                name: ::String,
                                connection_name: ::String,
                                connector_name: ::String,
                                connection_type: ::String,
                                additional_options: {
                                  filter_predicate: ::String?,
                                  partition_column: ::String?,
                                  lower_bound: ::Integer?,
                                  upper_bound: ::Integer?,
                                  num_partitions: ::Integer?,
                                  job_bookmark_keys: Array[::String]?,
                                  job_bookmark_keys_sort_order: ::String?,
                                  data_type_mapping: Hash[("ARRAY" | "BIGINT" | "BINARY" | "BIT" | "BLOB" | "BOOLEAN" | "CHAR" | "CLOB" | "DATALINK" | "DATE" | "DECIMAL" | "DISTINCT" | "DOUBLE" | "FLOAT" | "INTEGER" | "JAVA_OBJECT" | "LONGNVARCHAR" | "LONGVARBINARY" | "LONGVARCHAR" | "NCHAR" | "NCLOB" | "NULL" | "NUMERIC" | "NVARCHAR" | "OTHER" | "REAL" | "REF" | "REF_CURSOR" | "ROWID" | "SMALLINT" | "SQLXML" | "STRUCT" | "TIME" | "TIME_WITH_TIMEZONE" | "TIMESTAMP" | "TIMESTAMP_WITH_TIMEZONE" | "TINYINT" | "VARBINARY" | "VARCHAR"), ("DATE" | "STRING" | "TIMESTAMP" | "INT" | "FLOAT" | "LONG" | "BIGDECIMAL" | "BYTE" | "SHORT" | "DOUBLE")]?
                                }?,
                                connection_table: ::String?,
                                query: ::String?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              spark_connector_source: {
                                name: ::String,
                                connection_name: ::String,
                                connector_name: ::String,
                                connection_type: ::String,
                                additional_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              redshift_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                redshift_tmp_dir: ::String?,
                                tmp_dir_iam_role: ::String?
                              }?,
                              s3_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                partition_predicate: ::String?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?
                                }?
                              }?,
                              s3_csv_source: {
                                name: ::String,
                                paths: Array[::String],
                                compression_type: ("gzip" | "bzip2")?,
                                exclusions: Array[::String]?,
                                group_size: ::String?,
                                group_files: ::String?,
                                recurse: bool?,
                                max_band: ::Integer?,
                                max_files_in_band: ::Integer?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?,
                                  enable_sample_path: bool?,
                                  sample_path: ::String?
                                }?,
                                separator: ("comma" | "ctrla" | "pipe" | "semicolon" | "tab"),
                                escaper: ::String?,
                                quote_char: ("quote" | "quillemet" | "single_quote" | "disabled"),
                                multiline: bool?,
                                with_header: bool?,
                                write_header: bool?,
                                skip_first: bool?,
                                optimize_performance: bool?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_json_source: {
                                name: ::String,
                                paths: Array[::String],
                                compression_type: ("gzip" | "bzip2")?,
                                exclusions: Array[::String]?,
                                group_size: ::String?,
                                group_files: ::String?,
                                recurse: bool?,
                                max_band: ::Integer?,
                                max_files_in_band: ::Integer?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?,
                                  enable_sample_path: bool?,
                                  sample_path: ::String?
                                }?,
                                json_path: ::String?,
                                multiline: bool?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_parquet_source: {
                                name: ::String,
                                paths: Array[::String],
                                compression_type: ("snappy" | "lzo" | "gzip" | "uncompressed" | "none")?,
                                exclusions: Array[::String]?,
                                group_size: ::String?,
                                group_files: ::String?,
                                recurse: bool?,
                                max_band: ::Integer?,
                                max_files_in_band: ::Integer?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?,
                                  enable_sample_path: bool?,
                                  sample_path: ::String?
                                }?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              relational_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              dynamo_db_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              jdbc_connector_target: {
                                name: ::String,
                                inputs: Array[::String],
                                connection_name: ::String,
                                connection_table: ::String,
                                connector_name: ::String,
                                connection_type: ::String,
                                additional_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              spark_connector_target: {
                                name: ::String,
                                inputs: Array[::String],
                                connection_name: ::String,
                                connector_name: ::String,
                                connection_type: ::String,
                                additional_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String
                              }?,
                              redshift_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String,
                                redshift_tmp_dir: ::String?,
                                tmp_dir_iam_role: ::String?,
                                upsert_redshift_options: {
                                  table_location: ::String?,
                                  connection_name: ::String?,
                                  upsert_keys: Array[::String]?
                                }?
                              }?,
                              s3_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                table: ::String,
                                database: ::String,
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                                }?
                              }?,
                              s3_glue_parquet_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                path: ::String,
                                compression: ("snappy" | "lzo" | "gzip" | "uncompressed" | "none")?,
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                  table: ::String?,
                                  database: ::String?
                                }?
                              }?,
                              s3_direct_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                path: ::String,
                                compression: ::String?,
                                format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                  table: ::String?,
                                  database: ::String?
                                }?
                              }?,
                              apply_mapping: {
                                name: ::String,
                                inputs: Array[::String],
                                mapping: Array[
                                  {
                                    to_key: ::String?,
                                    from_path: Array[::String]?,
                                    from_type: ::String?,
                                    to_type: ::String?,
                                    dropped: bool?,
                                    children: untyped?
                                  },
                                ]
                              }?,
                              select_fields: {
                                name: ::String,
                                inputs: Array[::String],
                                paths: Array[
                                  Array[::String],
                                ]
                              }?,
                              drop_fields: {
                                name: ::String,
                                inputs: Array[::String],
                                paths: Array[
                                  Array[::String],
                                ]
                              }?,
                              rename_field: {
                                name: ::String,
                                inputs: Array[::String],
                                source_path: Array[::String],
                                target_path: Array[::String]
                              }?,
                              spigot: {
                                name: ::String,
                                inputs: Array[::String],
                                path: ::String,
                                topk: ::Integer?,
                                prob: ::Float?
                              }?,
                              join: {
                                name: ::String,
                                inputs: Array[::String],
                                join_type: ("equijoin" | "left" | "right" | "outer" | "leftsemi" | "leftanti"),
                                columns: Array[
                                  {
                                    from: ::String,
                                    keys: Array[
                                      Array[::String],
                                    ]
                                  },
                                ]
                              }?,
                              split_fields: {
                                name: ::String,
                                inputs: Array[::String],
                                paths: Array[
                                  Array[::String],
                                ]
                              }?,
                              select_from_collection: {
                                name: ::String,
                                inputs: Array[::String],
                                index: ::Integer
                              }?,
                              fill_missing_values: {
                                name: ::String,
                                inputs: Array[::String],
                                imputed_path: ::String,
                                filled_path: ::String?
                              }?,
                              filter: {
                                name: ::String,
                                inputs: Array[::String],
                                logical_operator: ("AND" | "OR"),
                                filters: Array[
                                  {
                                    operation: ("EQ" | "LT" | "GT" | "LTE" | "GTE" | "REGEX" | "ISNULL"),
                                    negated: bool?,
                                    values: Array[
                                      {
                                        type: ("COLUMNEXTRACTED" | "CONSTANT"),
                                        value: Array[::String]
                                      },
                                    ]
                                  },
                                ]
                              }?,
                              custom_code: {
                                name: ::String,
                                inputs: Array[::String],
                                code: ::String,
                                class_name: ::String,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              spark_sql: {
                                name: ::String,
                                inputs: Array[::String],
                                sql_query: ::String,
                                sql_aliases: Array[
                                  {
                                    from: ::String,
                                    alias: ::String
                                  },
                                ],
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              direct_kinesis_source: {
                                name: ::String,
                                window_size: ::Integer?,
                                detect_schema: bool?,
                                streaming_options: {
                                  endpoint_url: ::String?,
                                  stream_name: ::String?,
                                  classification: ::String?,
                                  delimiter: ::String?,
                                  starting_position: ("latest" | "trim_horizon" | "earliest" | "timestamp")?,
                                  max_fetch_time_in_ms: ::Integer?,
                                  max_fetch_records_per_shard: ::Integer?,
                                  max_record_per_read: ::Integer?,
                                  add_idle_time_between_reads: bool?,
                                  idle_time_between_reads_in_ms: ::Integer?,
                                  describe_shard_interval: ::Integer?,
                                  num_retries: ::Integer?,
                                  retry_interval_ms: ::Integer?,
                                  max_retry_interval_ms: ::Integer?,
                                  avoid_empty_batches: bool?,
                                  stream_arn: ::String?,
                                  role_arn: ::String?,
                                  role_session_name: ::String?,
                                  add_record_timestamp: ::String?,
                                  emit_consumer_lag_metrics: ::String?,
                                  starting_timestamp: ::Time?
                                }?,
                                data_preview_options: {
                                  polling_time: ::Integer?,
                                  record_polling_limit: ::Integer?
                                }?
                              }?,
                              direct_kafka_source: {
                                name: ::String,
                                streaming_options: {
                                  bootstrap_servers: ::String?,
                                  security_protocol: ::String?,
                                  connection_name: ::String?,
                                  topic_name: ::String?,
                                  assign: ::String?,
                                  subscribe_pattern: ::String?,
                                  classification: ::String?,
                                  delimiter: ::String?,
                                  starting_offsets: ::String?,
                                  ending_offsets: ::String?,
                                  poll_timeout_ms: ::Integer?,
                                  num_retries: ::Integer?,
                                  retry_interval_ms: ::Integer?,
                                  max_offsets_per_trigger: ::Integer?,
                                  min_partitions: ::Integer?,
                                  include_headers: bool?,
                                  add_record_timestamp: ::String?,
                                  emit_consumer_lag_metrics: ::String?,
                                  starting_timestamp: ::Time?
                                }?,
                                window_size: ::Integer?,
                                detect_schema: bool?,
                                data_preview_options: {
                                  polling_time: ::Integer?,
                                  record_polling_limit: ::Integer?
                                }?
                              }?,
                              catalog_kinesis_source: {
                                name: ::String,
                                window_size: ::Integer?,
                                detect_schema: bool?,
                                table: ::String,
                                database: ::String,
                                streaming_options: {
                                  endpoint_url: ::String?,
                                  stream_name: ::String?,
                                  classification: ::String?,
                                  delimiter: ::String?,
                                  starting_position: ("latest" | "trim_horizon" | "earliest" | "timestamp")?,
                                  max_fetch_time_in_ms: ::Integer?,
                                  max_fetch_records_per_shard: ::Integer?,
                                  max_record_per_read: ::Integer?,
                                  add_idle_time_between_reads: bool?,
                                  idle_time_between_reads_in_ms: ::Integer?,
                                  describe_shard_interval: ::Integer?,
                                  num_retries: ::Integer?,
                                  retry_interval_ms: ::Integer?,
                                  max_retry_interval_ms: ::Integer?,
                                  avoid_empty_batches: bool?,
                                  stream_arn: ::String?,
                                  role_arn: ::String?,
                                  role_session_name: ::String?,
                                  add_record_timestamp: ::String?,
                                  emit_consumer_lag_metrics: ::String?,
                                  starting_timestamp: ::Time?
                                }?,
                                data_preview_options: {
                                  polling_time: ::Integer?,
                                  record_polling_limit: ::Integer?
                                }?
                              }?,
                              catalog_kafka_source: {
                                name: ::String,
                                window_size: ::Integer?,
                                detect_schema: bool?,
                                table: ::String,
                                database: ::String,
                                streaming_options: {
                                  bootstrap_servers: ::String?,
                                  security_protocol: ::String?,
                                  connection_name: ::String?,
                                  topic_name: ::String?,
                                  assign: ::String?,
                                  subscribe_pattern: ::String?,
                                  classification: ::String?,
                                  delimiter: ::String?,
                                  starting_offsets: ::String?,
                                  ending_offsets: ::String?,
                                  poll_timeout_ms: ::Integer?,
                                  num_retries: ::Integer?,
                                  retry_interval_ms: ::Integer?,
                                  max_offsets_per_trigger: ::Integer?,
                                  min_partitions: ::Integer?,
                                  include_headers: bool?,
                                  add_record_timestamp: ::String?,
                                  emit_consumer_lag_metrics: ::String?,
                                  starting_timestamp: ::Time?
                                }?,
                                data_preview_options: {
                                  polling_time: ::Integer?,
                                  record_polling_limit: ::Integer?
                                }?
                              }?,
                              drop_null_fields: {
                                name: ::String,
                                inputs: Array[::String],
                                null_check_box_list: {
                                  is_empty: bool?,
                                  is_null_string: bool?,
                                  is_neg_one: bool?
                                }?,
                                null_text_list: Array[
                                  {
                                    value: ::String,
                                    datatype: {
                                      id: ::String,
                                      label: ::String
                                    }
                                  },
                                ]?
                              }?,
                              merge: {
                                name: ::String,
                                inputs: Array[::String],
                                source: ::String,
                                primary_keys: Array[
                                  Array[::String],
                                ]
                              }?,
                              union: {
                                name: ::String,
                                inputs: Array[::String],
                                union_type: ("ALL" | "DISTINCT")
                              }?,
                              pii_detection: {
                                name: ::String,
                                inputs: Array[::String],
                                pii_type: ("RowAudit" | "RowMasking" | "ColumnAudit" | "ColumnMasking"),
                                entity_types_to_detect: Array[::String],
                                output_column_name: ::String?,
                                sample_fraction: ::Float?,
                                threshold_fraction: ::Float?,
                                mask_value: ::String?
                              }?,
                              aggregate: {
                                name: ::String,
                                inputs: Array[::String],
                                groups: Array[
                                  Array[::String],
                                ],
                                aggs: Array[
                                  {
                                    column: Array[::String],
                                    agg_func: ("avg" | "countDistinct" | "count" | "first" | "last" | "kurtosis" | "max" | "min" | "skewness" | "stddev_samp" | "stddev_pop" | "sum" | "sumDistinct" | "var_samp" | "var_pop")
                                  },
                                ]
                              }?,
                              drop_duplicates: {
                                name: ::String,
                                inputs: Array[::String],
                                columns: Array[
                                  Array[::String],
                                ]?
                              }?,
                              governed_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                table: ::String,
                                database: ::String,
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                                }?
                              }?,
                              governed_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                partition_predicate: ::String?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?
                                }?
                              }?,
                              microsoft_sql_server_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              my_sql_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              oracle_sql_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              postgre_sql_catalog_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String
                              }?,
                              microsoft_sql_server_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String
                              }?,
                              my_sql_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String
                              }?,
                              oracle_sql_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String
                              }?,
                              postgre_sql_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                database: ::String,
                                table: ::String
                              }?,
                              dynamic_transform: {
                                name: ::String,
                                transform_name: ::String,
                                inputs: Array[::String],
                                parameters: Array[
                                  {
                                    name: ::String,
                                    type: ("str" | "int" | "float" | "complex" | "bool" | "list" | "null"),
                                    validation_rule: ::String?,
                                    validation_message: ::String?,
                                    value: Array[::String]?,
                                    list_type: ("str" | "int" | "float" | "complex" | "bool" | "list" | "null")?,
                                    is_optional: bool?
                                  },
                                ]?,
                                function_name: ::String,
                                path: ::String,
                                version: ::String?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              evaluate_data_quality: {
                                name: ::String,
                                inputs: Array[::String],
                                ruleset: ::String,
                                output: ("PrimaryInput" | "EvaluationResults")?,
                                publishing_options: {
                                  evaluation_context: ::String?,
                                  results_s3_prefix: ::String?,
                                  cloud_watch_metrics_enabled: bool?,
                                  results_publishing_enabled: bool?
                                }?,
                                stop_job_on_failure_options: {
                                  stop_job_on_failure_timing: ("Immediate" | "AfterDataLoad")?
                                }?
                              }?,
                              s3_catalog_hudi_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                additional_hudi_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              catalog_hudi_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                additional_hudi_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_hudi_source: {
                                name: ::String,
                                paths: Array[::String],
                                additional_hudi_options: Hash[::String, ::String]?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?,
                                  enable_sample_path: bool?,
                                  sample_path: ::String?
                                }?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_hudi_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                table: ::String,
                                database: ::String,
                                additional_options: Hash[::String, ::String],
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                                }?
                              }?,
                              s3_hudi_direct_target: {
                                name: ::String,
                                inputs: Array[::String],
                                path: ::String,
                                compression: ("gzip" | "lzo" | "uncompressed" | "snappy"),
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                                additional_options: Hash[::String, ::String],
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                  table: ::String?,
                                  database: ::String?
                                }?
                              }?,
                              direct_jdbc_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                connection_name: ::String,
                                connection_type: ("sqlserver" | "mysql" | "oracle" | "postgresql" | "redshift"),
                                redshift_tmp_dir: ::String?
                              }?,
                              s3_catalog_delta_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                additional_delta_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              catalog_delta_source: {
                                name: ::String,
                                database: ::String,
                                table: ::String,
                                additional_delta_options: Hash[::String, ::String]?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_delta_source: {
                                name: ::String,
                                paths: Array[::String],
                                additional_delta_options: Hash[::String, ::String]?,
                                additional_options: {
                                  bounded_size: ::Integer?,
                                  bounded_files: ::Integer?,
                                  enable_sample_path: bool?,
                                  sample_path: ::String?
                                }?,
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              s3_delta_catalog_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                table: ::String,
                                database: ::String,
                                additional_options: Hash[::String, ::String]?,
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?
                                }?
                              }?,
                              s3_delta_direct_target: {
                                name: ::String,
                                inputs: Array[::String],
                                partition_keys: Array[
                                  Array[::String],
                                ]?,
                                path: ::String,
                                compression: ("uncompressed" | "snappy"),
                                format: ("json" | "csv" | "avro" | "orc" | "parquet" | "hudi" | "delta"),
                                additional_options: Hash[::String, ::String]?,
                                schema_change_policy: {
                                  enable_update_catalog: bool?,
                                  update_behavior: ("UPDATE_IN_DATABASE" | "LOG")?,
                                  table: ::String?,
                                  database: ::String?
                                }?
                              }?,
                              amazon_redshift_source: {
                                name: ::String?,
                                data: {
                                  access_type: ::String?,
                                  source_type: ::String?,
                                  connection: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  schema: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  table: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_database: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_table: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_redshift_schema: ::String?,
                                  catalog_redshift_table: ::String?,
                                  temp_dir: ::String?,
                                  iam_role: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  advanced_options: Array[
                                    {
                                      key: ::String?,
                                      value: ::String?
                                    },
                                  ]?,
                                  sample_query: ::String?,
                                  pre_action: ::String?,
                                  post_action: ::String?,
                                  action: ::String?,
                                  table_prefix: ::String?,
                                  upsert: bool?,
                                  merge_action: ::String?,
                                  merge_when_matched: ::String?,
                                  merge_when_not_matched: ::String?,
                                  merge_clause: ::String?,
                                  crawler_connection: ::String?,
                                  table_schema: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?,
                                  staging_table: ::String?,
                                  selected_columns: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?
                                }?
                              }?,
                              amazon_redshift_target: {
                                name: ::String?,
                                data: {
                                  access_type: ::String?,
                                  source_type: ::String?,
                                  connection: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  schema: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  table: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_database: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_table: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  catalog_redshift_schema: ::String?,
                                  catalog_redshift_table: ::String?,
                                  temp_dir: ::String?,
                                  iam_role: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  advanced_options: Array[
                                    {
                                      key: ::String?,
                                      value: ::String?
                                    },
                                  ]?,
                                  sample_query: ::String?,
                                  pre_action: ::String?,
                                  post_action: ::String?,
                                  action: ::String?,
                                  table_prefix: ::String?,
                                  upsert: bool?,
                                  merge_action: ::String?,
                                  merge_when_matched: ::String?,
                                  merge_when_not_matched: ::String?,
                                  merge_clause: ::String?,
                                  crawler_connection: ::String?,
                                  table_schema: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?,
                                  staging_table: ::String?,
                                  selected_columns: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?
                                }?,
                                inputs: Array[::String]?
                              }?,
                              evaluate_data_quality_multi_frame: {
                                name: ::String,
                                inputs: Array[::String],
                                additional_data_sources: Hash[::String, ::String]?,
                                ruleset: ::String,
                                publishing_options: {
                                  evaluation_context: ::String?,
                                  results_s3_prefix: ::String?,
                                  cloud_watch_metrics_enabled: bool?,
                                  results_publishing_enabled: bool?
                                }?,
                                additional_options: Hash[("performanceTuning.caching" | "observations.scope"), ::String]?,
                                stop_job_on_failure_options: {
                                  stop_job_on_failure_timing: ("Immediate" | "AfterDataLoad")?
                                }?
                              }?,
                              recipe: {
                                name: ::String,
                                inputs: Array[::String],
                                recipe_reference: {
                                  recipe_arn: ::String,
                                  recipe_version: ::String
                                }
                              }?,
                              snowflake_source: {
                                name: ::String,
                                data: {
                                  source_type: ::String?,
                                  connection: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  schema: ::String?,
                                  table: ::String?,
                                  database: ::String?,
                                  temp_dir: ::String?,
                                  iam_role: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  additional_options: Hash[::String, ::String]?,
                                  sample_query: ::String?,
                                  pre_action: ::String?,
                                  post_action: ::String?,
                                  action: ::String?,
                                  upsert: bool?,
                                  merge_action: ::String?,
                                  merge_when_matched: ::String?,
                                  merge_when_not_matched: ::String?,
                                  merge_clause: ::String?,
                                  staging_table: ::String?,
                                  selected_columns: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?,
                                  auto_pushdown: bool?,
                                  table_schema: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?
                                },
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              snowflake_target: {
                                name: ::String,
                                data: {
                                  source_type: ::String?,
                                  connection: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  schema: ::String?,
                                  table: ::String?,
                                  database: ::String?,
                                  temp_dir: ::String?,
                                  iam_role: {
                                    value: ::String?,
                                    label: ::String?,
                                    description: ::String?
                                  }?,
                                  additional_options: Hash[::String, ::String]?,
                                  sample_query: ::String?,
                                  pre_action: ::String?,
                                  post_action: ::String?,
                                  action: ::String?,
                                  upsert: bool?,
                                  merge_action: ::String?,
                                  merge_when_matched: ::String?,
                                  merge_when_not_matched: ::String?,
                                  merge_clause: ::String?,
                                  staging_table: ::String?,
                                  selected_columns: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?,
                                  auto_pushdown: bool?,
                                  table_schema: Array[
                                    {
                                      value: ::String?,
                                      label: ::String?,
                                      description: ::String?
                                    },
                                  ]?
                                },
                                inputs: Array[::String]?
                              }?,
                              connector_data_source: {
                                name: ::String,
                                connection_type: ::String,
                                data: Hash[::String, ::String],
                                output_schemas: Array[
                                  {
                                    columns: Array[
                                      {
                                        name: ::String,
                                        type: ::String?
                                      },
                                    ]?
                                  },
                                ]?
                              }?,
                              connector_data_target: {
                                name: ::String,
                                connection_type: ::String,
                                data: Hash[::String, ::String],
                                inputs: Array[::String]?
                              }?
                            }]?,
                          execution_class: ("FLEX" | "STANDARD")?,
                          source_control_details: {
                            provider: ("GITHUB" | "GITLAB" | "BITBUCKET" | "AWS_CODE_COMMIT")?,
                            repository: ::String?,
                            owner: ::String?,
                            branch: ::String?,
                            folder: ::String?,
                            last_commit_id: ::String?,
                            auth_strategy: ("PERSONAL_ACCESS_TOKEN" | "AWS_SECRETS_MANAGER")?,
                            auth_token: ::String?
                          }?,
                          maintenance_window: ::String?
                        }
                      ) -> _UpdateJobResponseSuccess
                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateJobResponseSuccess

      interface _UpdateJobFromSourceControlResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateJobFromSourceControlResponse]
        def job_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_job_from_source_control-instance_method
      def update_job_from_source_control: (
                                            ?job_name: ::String,
                                            ?provider: ("GITHUB" | "GITLAB" | "BITBUCKET" | "AWS_CODE_COMMIT"),
                                            ?repository_name: ::String,
                                            ?repository_owner: ::String,
                                            ?branch_name: ::String,
                                            ?folder: ::String,
                                            ?commit_id: ::String,
                                            ?auth_strategy: ("PERSONAL_ACCESS_TOKEN" | "AWS_SECRETS_MANAGER"),
                                            ?auth_token: ::String
                                          ) -> _UpdateJobFromSourceControlResponseSuccess
                                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateJobFromSourceControlResponseSuccess

      interface _UpdateMLTransformResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateMLTransformResponse]
        def transform_id: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_ml_transform-instance_method
      def update_ml_transform: (
                                 transform_id: ::String,
                                 ?name: ::String,
                                 ?description: ::String,
                                 ?parameters: {
                                   transform_type: ("FIND_MATCHES"),
                                   find_matches_parameters: {
                                     primary_key_column_name: ::String?,
                                     precision_recall_tradeoff: ::Float?,
                                     accuracy_cost_tradeoff: ::Float?,
                                     enforce_provided_labels: bool?
                                   }?
                                 },
                                 ?role: ::String,
                                 ?glue_version: ::String,
                                 ?max_capacity: ::Float,
                                 ?worker_type: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X"),
                                 ?number_of_workers: ::Integer,
                                 ?timeout: ::Integer,
                                 ?max_retries: ::Integer
                               ) -> _UpdateMLTransformResponseSuccess
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateMLTransformResponseSuccess

      interface _UpdatePartitionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdatePartitionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_partition-instance_method
      def update_partition: (
                              ?catalog_id: ::String,
                              database_name: ::String,
                              table_name: ::String,
                              partition_value_list: Array[::String],
                              partition_input: {
                                values: Array[::String]?,
                                last_access_time: ::Time?,
                                storage_descriptor: {
                                  columns: Array[
                                    {
                                      name: ::String,
                                      type: ::String?,
                                      comment: ::String?,
                                      parameters: Hash[::String, ::String]?
                                    },
                                  ]?,
                                  location: ::String?,
                                  additional_locations: Array[::String]?,
                                  input_format: ::String?,
                                  output_format: ::String?,
                                  compressed: bool?,
                                  number_of_buckets: ::Integer?,
                                  serde_info: {
                                    name: ::String?,
                                    serialization_library: ::String?,
                                    parameters: Hash[::String, ::String]?
                                  }?,
                                  bucket_columns: Array[::String]?,
                                  sort_columns: Array[
                                    {
                                      column: ::String,
                                      sort_order: ::Integer
                                    },
                                  ]?,
                                  parameters: Hash[::String, ::String]?,
                                  skewed_info: {
                                    skewed_column_names: Array[::String]?,
                                    skewed_column_values: Array[::String]?,
                                    skewed_column_value_location_maps: Hash[::String, ::String]?
                                  }?,
                                  stored_as_sub_directories: bool?,
                                  schema_reference: {
                                    schema_id: {
                                      schema_arn: ::String?,
                                      schema_name: ::String?,
                                      registry_name: ::String?
                                    }?,
                                    schema_version_id: ::String?,
                                    schema_version_number: ::Integer?
                                  }?
                                }?,
                                parameters: Hash[::String, ::String]?,
                                last_analyzed_time: ::Time?
                              }
                            ) -> _UpdatePartitionResponseSuccess
                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdatePartitionResponseSuccess

      interface _UpdateRegistryResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateRegistryResponse]
        def registry_name: () -> ::String
        def registry_arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_registry-instance_method
      def update_registry: (
                             registry_id: {
                               registry_name: ::String?,
                               registry_arn: ::String?
                             },
                             description: ::String
                           ) -> _UpdateRegistryResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateRegistryResponseSuccess

      interface _UpdateSchemaResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateSchemaResponse]
        def schema_arn: () -> ::String
        def schema_name: () -> ::String
        def registry_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_schema-instance_method
      def update_schema: (
                           schema_id: {
                             schema_arn: ::String?,
                             schema_name: ::String?,
                             registry_name: ::String?
                           },
                           ?schema_version_number: {
                             latest_version: bool?,
                             version_number: ::Integer?
                           },
                           ?compatibility: ("NONE" | "DISABLED" | "BACKWARD" | "BACKWARD_ALL" | "FORWARD" | "FORWARD_ALL" | "FULL" | "FULL_ALL"),
                           ?description: ::String
                         ) -> _UpdateSchemaResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateSchemaResponseSuccess

      interface _UpdateSourceControlFromJobResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateSourceControlFromJobResponse]
        def job_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_source_control_from_job-instance_method
      def update_source_control_from_job: (
                                            ?job_name: ::String,
                                            ?provider: ("GITHUB" | "GITLAB" | "BITBUCKET" | "AWS_CODE_COMMIT"),
                                            ?repository_name: ::String,
                                            ?repository_owner: ::String,
                                            ?branch_name: ::String,
                                            ?folder: ::String,
                                            ?commit_id: ::String,
                                            ?auth_strategy: ("PERSONAL_ACCESS_TOKEN" | "AWS_SECRETS_MANAGER"),
                                            ?auth_token: ::String
                                          ) -> _UpdateSourceControlFromJobResponseSuccess
                                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateSourceControlFromJobResponseSuccess

      interface _UpdateTableResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTableResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_table-instance_method
      def update_table: (
                          ?catalog_id: ::String,
                          database_name: ::String,
                          table_input: {
                            name: ::String,
                            description: ::String?,
                            owner: ::String?,
                            last_access_time: ::Time?,
                            last_analyzed_time: ::Time?,
                            retention: ::Integer?,
                            storage_descriptor: {
                              columns: Array[
                                {
                                  name: ::String,
                                  type: ::String?,
                                  comment: ::String?,
                                  parameters: Hash[::String, ::String]?
                                },
                              ]?,
                              location: ::String?,
                              additional_locations: Array[::String]?,
                              input_format: ::String?,
                              output_format: ::String?,
                              compressed: bool?,
                              number_of_buckets: ::Integer?,
                              serde_info: {
                                name: ::String?,
                                serialization_library: ::String?,
                                parameters: Hash[::String, ::String]?
                              }?,
                              bucket_columns: Array[::String]?,
                              sort_columns: Array[
                                {
                                  column: ::String,
                                  sort_order: ::Integer
                                },
                              ]?,
                              parameters: Hash[::String, ::String]?,
                              skewed_info: {
                                skewed_column_names: Array[::String]?,
                                skewed_column_values: Array[::String]?,
                                skewed_column_value_location_maps: Hash[::String, ::String]?
                              }?,
                              stored_as_sub_directories: bool?,
                              schema_reference: {
                                schema_id: {
                                  schema_arn: ::String?,
                                  schema_name: ::String?,
                                  registry_name: ::String?
                                }?,
                                schema_version_id: ::String?,
                                schema_version_number: ::Integer?
                              }?
                            }?,
                            partition_keys: Array[
                              {
                                name: ::String,
                                type: ::String?,
                                comment: ::String?,
                                parameters: Hash[::String, ::String]?
                              },
                            ]?,
                            view_original_text: ::String?,
                            view_expanded_text: ::String?,
                            table_type: ::String?,
                            parameters: Hash[::String, ::String]?,
                            target_table: {
                              catalog_id: ::String?,
                              database_name: ::String?,
                              name: ::String?,
                              region: ::String?
                            }?
                          },
                          ?skip_archive: bool,
                          ?transaction_id: ::String,
                          ?version_id: ::String
                        ) -> _UpdateTableResponseSuccess
                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTableResponseSuccess

      interface _UpdateTableOptimizerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTableOptimizerResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_table_optimizer-instance_method
      def update_table_optimizer: (
                                    catalog_id: ::String,
                                    database_name: ::String,
                                    table_name: ::String,
                                    type: ("compaction"),
                                    table_optimizer_configuration: {
                                      role_arn: ::String?,
                                      enabled: bool?
                                    }
                                  ) -> _UpdateTableOptimizerResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTableOptimizerResponseSuccess

      interface _UpdateTriggerResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateTriggerResponse]
        def trigger: () -> Types::Trigger
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_trigger-instance_method
      def update_trigger: (
                            name: ::String,
                            trigger_update: {
                              name: ::String?,
                              description: ::String?,
                              schedule: ::String?,
                              actions: Array[
                                {
                                  job_name: ::String?,
                                  arguments: Hash[::String, ::String]?,
                                  timeout: ::Integer?,
                                  security_configuration: ::String?,
                                  notification_property: {
                                    notify_delay_after: ::Integer?
                                  }?,
                                  crawler_name: ::String?
                                },
                              ]?,
                              predicate: {
                                logical: ("AND" | "ANY")?,
                                conditions: Array[
                                  {
                                    logical_operator: ("EQUALS")?,
                                    job_name: ::String?,
                                    state: ("STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "SUCCEEDED" | "FAILED" | "TIMEOUT" | "ERROR" | "WAITING" | "EXPIRED")?,
                                    crawler_name: ::String?,
                                    crawl_state: ("RUNNING" | "CANCELLING" | "CANCELLED" | "SUCCEEDED" | "FAILED" | "ERROR")?
                                  },
                                ]?
                              }?,
                              event_batching_condition: {
                                batch_size: ::Integer,
                                batch_window: ::Integer?
                              }?
                            }
                          ) -> _UpdateTriggerResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateTriggerResponseSuccess

      interface _UpdateUserDefinedFunctionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateUserDefinedFunctionResponse]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_user_defined_function-instance_method
      def update_user_defined_function: (
                                          ?catalog_id: ::String,
                                          database_name: ::String,
                                          function_name: ::String,
                                          function_input: {
                                            function_name: ::String?,
                                            class_name: ::String?,
                                            owner_name: ::String?,
                                            owner_type: ("USER" | "ROLE" | "GROUP")?,
                                            resource_uris: Array[
                                              {
                                                resource_type: ("JAR" | "FILE" | "ARCHIVE")?,
                                                uri: ::String?
                                              },
                                            ]?
                                          }
                                        ) -> _UpdateUserDefinedFunctionResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateUserDefinedFunctionResponseSuccess

      interface _UpdateWorkflowResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateWorkflowResponse]
        def name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Glue/Client.html#update_workflow-instance_method
      def update_workflow: (
                             name: ::String,
                             ?description: ::String,
                             ?default_run_properties: Hash[::String, ::String],
                             ?max_concurrent_runs: ::Integer
                           ) -> _UpdateWorkflowResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateWorkflowResponseSuccess
    end
  end
end