aws-sdk-frauddetector 1.48.0 → 1.49.0

data/sig/client.rbs

@@ -0,0 +1,1199 @@
+# 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 FraudDetector
+    class Client < ::Seahorse::Client::Base
+      include ::Aws::ClientStubs
+
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/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 _BatchCreateVariableResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::BatchCreateVariableResult]
+        def errors: () -> ::Array[Types::BatchCreateVariableError]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#batch_create_variable-instance_method
+      def batch_create_variable: (
+                                   variable_entries: Array[
+                                     {
+                                       name: ::String?,
+                                       data_type: ::String?,
+                                       data_source: ::String?,
+                                       default_value: ::String?,
+                                       description: ::String?,
+                                       variable_type: ::String?
+                                     },
+                                   ],
+                                   ?tags: Array[
+                                     {
+                                       key: ::String,
+                                       value: ::String
+                                     },
+                                   ]
+                                 ) -> _BatchCreateVariableResponseSuccess
+                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchCreateVariableResponseSuccess
+
+      interface _BatchGetVariableResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::BatchGetVariableResult]
+        def variables: () -> ::Array[Types::Variable]
+        def errors: () -> ::Array[Types::BatchGetVariableError]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#batch_get_variable-instance_method
+      def batch_get_variable: (
+                                names: Array[::String]
+                              ) -> _BatchGetVariableResponseSuccess
+                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchGetVariableResponseSuccess
+
+      interface _CancelBatchImportJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CancelBatchImportJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#cancel_batch_import_job-instance_method
+      def cancel_batch_import_job: (
+                                     job_id: ::String
+                                   ) -> _CancelBatchImportJobResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CancelBatchImportJobResponseSuccess
+
+      interface _CancelBatchPredictionJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CancelBatchPredictionJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#cancel_batch_prediction_job-instance_method
+      def cancel_batch_prediction_job: (
+                                         job_id: ::String
+                                       ) -> _CancelBatchPredictionJobResponseSuccess
+                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CancelBatchPredictionJobResponseSuccess
+
+      interface _CreateBatchImportJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateBatchImportJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_batch_import_job-instance_method
+      def create_batch_import_job: (
+                                     job_id: ::String,
+                                     input_path: ::String,
+                                     output_path: ::String,
+                                     event_type_name: ::String,
+                                     iam_role_arn: ::String,
+                                     ?tags: Array[
+                                       {
+                                         key: ::String,
+                                         value: ::String
+                                       },
+                                     ]
+                                   ) -> _CreateBatchImportJobResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateBatchImportJobResponseSuccess
+
+      interface _CreateBatchPredictionJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateBatchPredictionJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_batch_prediction_job-instance_method
+      def create_batch_prediction_job: (
+                                         job_id: ::String,
+                                         input_path: ::String,
+                                         output_path: ::String,
+                                         event_type_name: ::String,
+                                         detector_name: ::String,
+                                         ?detector_version: ::String,
+                                         iam_role_arn: ::String,
+                                         ?tags: Array[
+                                           {
+                                             key: ::String,
+                                             value: ::String
+                                           },
+                                         ]
+                                       ) -> _CreateBatchPredictionJobResponseSuccess
+                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateBatchPredictionJobResponseSuccess
+
+      interface _CreateDetectorVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateDetectorVersionResult]
+        def detector_id: () -> ::String
+        def detector_version_id: () -> ::String
+        def status: () -> ("DRAFT" | "ACTIVE" | "INACTIVE")
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_detector_version-instance_method
+      def create_detector_version: (
+                                     detector_id: ::String,
+                                     ?description: ::String,
+                                     ?external_model_endpoints: Array[::String],
+                                     rules: Array[
+                                       {
+                                         detector_id: ::String,
+                                         rule_id: ::String,
+                                         rule_version: ::String
+                                       },
+                                     ],
+                                     ?model_versions: Array[
+                                       {
+                                         model_id: ::String,
+                                         model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                         model_version_number: ::String,
+                                         arn: ::String?
+                                       },
+                                     ],
+                                     ?rule_execution_mode: ("ALL_MATCHED" | "FIRST_MATCHED"),
+                                     ?tags: Array[
+                                       {
+                                         key: ::String,
+                                         value: ::String
+                                       },
+                                     ]
+                                   ) -> _CreateDetectorVersionResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDetectorVersionResponseSuccess
+
+      interface _CreateListResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateListResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_list-instance_method
+      def create_list: (
+                         name: ::String,
+                         ?elements: Array[::String],
+                         ?variable_type: ::String,
+                         ?description: ::String,
+                         ?tags: Array[
+                           {
+                             key: ::String,
+                             value: ::String
+                           },
+                         ]
+                       ) -> _CreateListResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateListResponseSuccess
+
+      interface _CreateModelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateModelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_model-instance_method
+      def create_model: (
+                          model_id: ::String,
+                          model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                          ?description: ::String,
+                          event_type_name: ::String,
+                          ?tags: Array[
+                            {
+                              key: ::String,
+                              value: ::String
+                            },
+                          ]
+                        ) -> _CreateModelResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateModelResponseSuccess
+
+      interface _CreateModelVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateModelVersionResult]
+        def model_id: () -> ::String
+        def model_type: () -> ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS")
+        def model_version_number: () -> ::String
+        def status: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_model_version-instance_method
+      def create_model_version: (
+                                  model_id: ::String,
+                                  model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                  training_data_source: ("EXTERNAL_EVENTS" | "INGESTED_EVENTS"),
+                                  training_data_schema: {
+                                    model_variables: Array[::String],
+                                    label_schema: {
+                                      label_mapper: Hash[::String, Array[::String]]?,
+                                      unlabeled_events_treatment: ("IGNORE" | "FRAUD" | "LEGIT" | "AUTO")?
+                                    }?
+                                  },
+                                  ?external_events_detail: {
+                                    data_location: ::String,
+                                    data_access_role_arn: ::String
+                                  },
+                                  ?ingested_events_detail: {
+                                    ingested_events_time_window: {
+                                      start_time: ::String,
+                                      end_time: ::String
+                                    }
+                                  },
+                                  ?tags: Array[
+                                    {
+                                      key: ::String,
+                                      value: ::String
+                                    },
+                                  ]
+                                ) -> _CreateModelVersionResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateModelVersionResponseSuccess
+
+      interface _CreateRuleResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateRuleResult]
+        def rule: () -> Types::Rule
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_rule-instance_method
+      def create_rule: (
+                         rule_id: ::String,
+                         detector_id: ::String,
+                         ?description: ::String,
+                         expression: ::String,
+                         language: ("DETECTORPL"),
+                         outcomes: Array[::String],
+                         ?tags: Array[
+                           {
+                             key: ::String,
+                             value: ::String
+                           },
+                         ]
+                       ) -> _CreateRuleResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateRuleResponseSuccess
+
+      interface _CreateVariableResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::CreateVariableResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#create_variable-instance_method
+      def create_variable: (
+                             name: ::String,
+                             data_type: ("STRING" | "INTEGER" | "FLOAT" | "BOOLEAN" | "DATETIME"),
+                             data_source: ("EVENT" | "MODEL_SCORE" | "EXTERNAL_MODEL_SCORE"),
+                             default_value: ::String,
+                             ?description: ::String,
+                             ?variable_type: ::String,
+                             ?tags: Array[
+                               {
+                                 key: ::String,
+                                 value: ::String
+                               },
+                             ]
+                           ) -> _CreateVariableResponseSuccess
+                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateVariableResponseSuccess
+
+      interface _DeleteBatchImportJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteBatchImportJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_batch_import_job-instance_method
+      def delete_batch_import_job: (
+                                     job_id: ::String
+                                   ) -> _DeleteBatchImportJobResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteBatchImportJobResponseSuccess
+
+      interface _DeleteBatchPredictionJobResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteBatchPredictionJobResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_batch_prediction_job-instance_method
+      def delete_batch_prediction_job: (
+                                         job_id: ::String
+                                       ) -> _DeleteBatchPredictionJobResponseSuccess
+                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteBatchPredictionJobResponseSuccess
+
+      interface _DeleteDetectorResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteDetectorResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_detector-instance_method
+      def delete_detector: (
+                             detector_id: ::String
+                           ) -> _DeleteDetectorResponseSuccess
+                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteDetectorResponseSuccess
+
+      interface _DeleteDetectorVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteDetectorVersionResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_detector_version-instance_method
+      def delete_detector_version: (
+                                     detector_id: ::String,
+                                     detector_version_id: ::String
+                                   ) -> _DeleteDetectorVersionResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteDetectorVersionResponseSuccess
+
+      interface _DeleteEntityTypeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteEntityTypeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_entity_type-instance_method
+      def delete_entity_type: (
+                                name: ::String
+                              ) -> _DeleteEntityTypeResponseSuccess
+                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteEntityTypeResponseSuccess
+
+      interface _DeleteEventResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteEventResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_event-instance_method
+      def delete_event: (
+                          event_id: ::String,
+                          event_type_name: ::String,
+                          ?delete_audit_history: bool
+                        ) -> _DeleteEventResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteEventResponseSuccess
+
+      interface _DeleteEventTypeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteEventTypeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_event_type-instance_method
+      def delete_event_type: (
+                               name: ::String
+                             ) -> _DeleteEventTypeResponseSuccess
+                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteEventTypeResponseSuccess
+
+      interface _DeleteEventsByEventTypeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteEventsByEventTypeResult]
+        def event_type_name: () -> ::String
+        def events_deletion_status: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_events_by_event_type-instance_method
+      def delete_events_by_event_type: (
+                                         event_type_name: ::String
+                                       ) -> _DeleteEventsByEventTypeResponseSuccess
+                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteEventsByEventTypeResponseSuccess
+
+      interface _DeleteExternalModelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteExternalModelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_external_model-instance_method
+      def delete_external_model: (
+                                   model_endpoint: ::String
+                                 ) -> _DeleteExternalModelResponseSuccess
+                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteExternalModelResponseSuccess
+
+      interface _DeleteLabelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteLabelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_label-instance_method
+      def delete_label: (
+                          name: ::String
+                        ) -> _DeleteLabelResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteLabelResponseSuccess
+
+      interface _DeleteListResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteListResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_list-instance_method
+      def delete_list: (
+                         name: ::String
+                       ) -> _DeleteListResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteListResponseSuccess
+
+      interface _DeleteModelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteModelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_model-instance_method
+      def delete_model: (
+                          model_id: ::String,
+                          model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS")
+                        ) -> _DeleteModelResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteModelResponseSuccess
+
+      interface _DeleteModelVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteModelVersionResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_model_version-instance_method
+      def delete_model_version: (
+                                  model_id: ::String,
+                                  model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                  model_version_number: ::String
+                                ) -> _DeleteModelVersionResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteModelVersionResponseSuccess
+
+      interface _DeleteOutcomeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteOutcomeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_outcome-instance_method
+      def delete_outcome: (
+                            name: ::String
+                          ) -> _DeleteOutcomeResponseSuccess
+                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteOutcomeResponseSuccess
+
+      interface _DeleteRuleResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteRuleResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_rule-instance_method
+      def delete_rule: (
+                         rule: {
+                           detector_id: ::String,
+                           rule_id: ::String,
+                           rule_version: ::String
+                         }
+                       ) -> _DeleteRuleResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteRuleResponseSuccess
+
+      interface _DeleteVariableResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteVariableResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#delete_variable-instance_method
+      def delete_variable: (
+                             name: ::String
+                           ) -> _DeleteVariableResponseSuccess
+                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteVariableResponseSuccess
+
+      interface _DescribeDetectorResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDetectorResult]
+        def detector_id: () -> ::String
+        def detector_version_summaries: () -> ::Array[Types::DetectorVersionSummary]
+        def next_token: () -> ::String
+        def arn: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#describe_detector-instance_method
+      def describe_detector: (
+                               detector_id: ::String,
+                               ?next_token: ::String,
+                               ?max_results: ::Integer
+                             ) -> _DescribeDetectorResponseSuccess
+                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDetectorResponseSuccess
+
+      interface _DescribeModelVersionsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeModelVersionsResult]
+        def model_version_details: () -> ::Array[Types::ModelVersionDetail]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#describe_model_versions-instance_method
+      def describe_model_versions: (
+                                     ?model_id: ::String,
+                                     ?model_version_number: ::String,
+                                     ?model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                     ?next_token: ::String,
+                                     ?max_results: ::Integer
+                                   ) -> _DescribeModelVersionsResponseSuccess
+                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeModelVersionsResponseSuccess
+
+      interface _GetBatchImportJobsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetBatchImportJobsResult]
+        def batch_imports: () -> ::Array[Types::BatchImport]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_batch_import_jobs-instance_method
+      def get_batch_import_jobs: (
+                                   ?job_id: ::String,
+                                   ?max_results: ::Integer,
+                                   ?next_token: ::String
+                                 ) -> _GetBatchImportJobsResponseSuccess
+                               | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBatchImportJobsResponseSuccess
+
+      interface _GetBatchPredictionJobsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetBatchPredictionJobsResult]
+        def batch_predictions: () -> ::Array[Types::BatchPrediction]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_batch_prediction_jobs-instance_method
+      def get_batch_prediction_jobs: (
+                                       ?job_id: ::String,
+                                       ?max_results: ::Integer,
+                                       ?next_token: ::String
+                                     ) -> _GetBatchPredictionJobsResponseSuccess
+                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetBatchPredictionJobsResponseSuccess
+
+      interface _GetDeleteEventsByEventTypeStatusResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetDeleteEventsByEventTypeStatusResult]
+        def event_type_name: () -> ::String
+        def events_deletion_status: () -> ("IN_PROGRESS_INITIALIZING" | "IN_PROGRESS" | "CANCEL_IN_PROGRESS" | "CANCELED" | "COMPLETE" | "FAILED")
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_delete_events_by_event_type_status-instance_method
+      def get_delete_events_by_event_type_status: (
+                                                    event_type_name: ::String
+                                                  ) -> _GetDeleteEventsByEventTypeStatusResponseSuccess
+                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDeleteEventsByEventTypeStatusResponseSuccess
+
+      interface _GetDetectorVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetDetectorVersionResult]
+        def detector_id: () -> ::String
+        def detector_version_id: () -> ::String
+        def description: () -> ::String
+        def external_model_endpoints: () -> ::Array[::String]
+        def model_versions: () -> ::Array[Types::ModelVersion]
+        def rules: () -> ::Array[Types::Rule]
+        def status: () -> ("DRAFT" | "ACTIVE" | "INACTIVE")
+        def last_updated_time: () -> ::String
+        def created_time: () -> ::String
+        def rule_execution_mode: () -> ("ALL_MATCHED" | "FIRST_MATCHED")
+        def arn: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_detector_version-instance_method
+      def get_detector_version: (
+                                  detector_id: ::String,
+                                  detector_version_id: ::String
+                                ) -> _GetDetectorVersionResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDetectorVersionResponseSuccess
+
+      interface _GetDetectorsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetDetectorsResult]
+        def detectors: () -> ::Array[Types::Detector]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_detectors-instance_method
+      def get_detectors: (
+                           ?detector_id: ::String,
+                           ?next_token: ::String,
+                           ?max_results: ::Integer
+                         ) -> _GetDetectorsResponseSuccess
+                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetDetectorsResponseSuccess
+
+      interface _GetEntityTypesResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetEntityTypesResult]
+        def entity_types: () -> ::Array[Types::EntityType]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_entity_types-instance_method
+      def get_entity_types: (
+                              ?name: ::String,
+                              ?next_token: ::String,
+                              ?max_results: ::Integer
+                            ) -> _GetEntityTypesResponseSuccess
+                          | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEntityTypesResponseSuccess
+
+      interface _GetEventResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetEventResult]
+        def event: () -> Types::Event
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_event-instance_method
+      def get_event: (
+                       event_id: ::String,
+                       event_type_name: ::String
+                     ) -> _GetEventResponseSuccess
+                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEventResponseSuccess
+
+      interface _GetEventPredictionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetEventPredictionResult]
+        def model_scores: () -> ::Array[Types::ModelScores]
+        def rule_results: () -> ::Array[Types::RuleResult]
+        def external_model_outputs: () -> ::Array[Types::ExternalModelOutputs]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_event_prediction-instance_method
+      def get_event_prediction: (
+                                  detector_id: ::String,
+                                  ?detector_version_id: ::String,
+                                  event_id: ::String,
+                                  event_type_name: ::String,
+                                  entities: Array[
+                                    {
+                                      entity_type: ::String,
+                                      entity_id: ::String
+                                    },
+                                  ],
+                                  event_timestamp: ::String,
+                                  event_variables: Hash[::String, ::String],
+                                  ?external_model_endpoint_data_blobs: Hash[::String, {
+                                      byte_buffer: ::String?,
+                                      content_type: ::String?
+                                    }]
+                                ) -> _GetEventPredictionResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEventPredictionResponseSuccess
+
+      interface _GetEventPredictionMetadataResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetEventPredictionMetadataResult]
+        def event_id: () -> ::String
+        def event_type_name: () -> ::String
+        def entity_id: () -> ::String
+        def entity_type: () -> ::String
+        def event_timestamp: () -> ::String
+        def detector_id: () -> ::String
+        def detector_version_id: () -> ::String
+        def detector_version_status: () -> ::String
+        def event_variables: () -> ::Array[Types::EventVariableSummary]
+        def rules: () -> ::Array[Types::EvaluatedRule]
+        def rule_execution_mode: () -> ("ALL_MATCHED" | "FIRST_MATCHED")
+        def outcomes: () -> ::Array[::String]
+        def evaluated_model_versions: () -> ::Array[Types::EvaluatedModelVersion]
+        def evaluated_external_models: () -> ::Array[Types::EvaluatedExternalModel]
+        def prediction_timestamp: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_event_prediction_metadata-instance_method
+      def get_event_prediction_metadata: (
+                                           event_id: ::String,
+                                           event_type_name: ::String,
+                                           detector_id: ::String,
+                                           detector_version_id: ::String,
+                                           prediction_timestamp: ::String
+                                         ) -> _GetEventPredictionMetadataResponseSuccess
+                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEventPredictionMetadataResponseSuccess
+
+      interface _GetEventTypesResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetEventTypesResult]
+        def event_types: () -> ::Array[Types::EventType]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_event_types-instance_method
+      def get_event_types: (
+                             ?name: ::String,
+                             ?next_token: ::String,
+                             ?max_results: ::Integer
+                           ) -> _GetEventTypesResponseSuccess
+                         | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetEventTypesResponseSuccess
+
+      interface _GetExternalModelsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetExternalModelsResult]
+        def external_models: () -> ::Array[Types::ExternalModel]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_external_models-instance_method
+      def get_external_models: (
+                                 ?model_endpoint: ::String,
+                                 ?next_token: ::String,
+                                 ?max_results: ::Integer
+                               ) -> _GetExternalModelsResponseSuccess
+                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetExternalModelsResponseSuccess
+
+      interface _GetKMSEncryptionKeyResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetKMSEncryptionKeyResult]
+        def kms_key: () -> Types::KMSKey
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_kms_encryption_key-instance_method
+      def get_kms_encryption_key: () -> _GetKMSEncryptionKeyResponseSuccess
+                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetKMSEncryptionKeyResponseSuccess
+
+      interface _GetLabelsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetLabelsResult]
+        def labels: () -> ::Array[Types::Label]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_labels-instance_method
+      def get_labels: (
+                        ?name: ::String,
+                        ?next_token: ::String,
+                        ?max_results: ::Integer
+                      ) -> _GetLabelsResponseSuccess
+                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetLabelsResponseSuccess
+
+      interface _GetListElementsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetListElementsResult]
+        def elements: () -> ::Array[::String]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_list_elements-instance_method
+      def get_list_elements: (
+                               name: ::String,
+                               ?next_token: ::String,
+                               ?max_results: ::Integer
+                             ) -> _GetListElementsResponseSuccess
+                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetListElementsResponseSuccess
+
+      interface _GetListsMetadataResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetListsMetadataResult]
+        def lists: () -> ::Array[Types::AllowDenyList]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_lists_metadata-instance_method
+      def get_lists_metadata: (
+                                ?name: ::String,
+                                ?next_token: ::String,
+                                ?max_results: ::Integer
+                              ) -> _GetListsMetadataResponseSuccess
+                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetListsMetadataResponseSuccess
+
+      interface _GetModelVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetModelVersionResult]
+        def model_id: () -> ::String
+        def model_type: () -> ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS")
+        def model_version_number: () -> ::String
+        def training_data_source: () -> ("EXTERNAL_EVENTS" | "INGESTED_EVENTS")
+        def training_data_schema: () -> Types::TrainingDataSchema
+        def external_events_detail: () -> Types::ExternalEventsDetail
+        def ingested_events_detail: () -> Types::IngestedEventsDetail
+        def status: () -> ::String
+        def arn: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_model_version-instance_method
+      def get_model_version: (
+                               model_id: ::String,
+                               model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                               model_version_number: ::String
+                             ) -> _GetModelVersionResponseSuccess
+                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetModelVersionResponseSuccess
+
+      interface _GetModelsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetModelsResult]
+        def next_token: () -> ::String
+        def models: () -> ::Array[Types::Model]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_models-instance_method
+      def get_models: (
+                        ?model_id: ::String,
+                        ?model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                        ?next_token: ::String,
+                        ?max_results: ::Integer
+                      ) -> _GetModelsResponseSuccess
+                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetModelsResponseSuccess
+
+      interface _GetOutcomesResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetOutcomesResult]
+        def outcomes: () -> ::Array[Types::Outcome]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_outcomes-instance_method
+      def get_outcomes: (
+                          ?name: ::String,
+                          ?next_token: ::String,
+                          ?max_results: ::Integer
+                        ) -> _GetOutcomesResponseSuccess
+                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetOutcomesResponseSuccess
+
+      interface _GetRulesResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetRulesResult]
+        def rule_details: () -> ::Array[Types::RuleDetail]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_rules-instance_method
+      def get_rules: (
+                       ?rule_id: ::String,
+                       detector_id: ::String,
+                       ?rule_version: ::String,
+                       ?next_token: ::String,
+                       ?max_results: ::Integer
+                     ) -> _GetRulesResponseSuccess
+                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetRulesResponseSuccess
+
+      interface _GetVariablesResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::GetVariablesResult]
+        def variables: () -> ::Array[Types::Variable]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#get_variables-instance_method
+      def get_variables: (
+                           ?name: ::String,
+                           ?next_token: ::String,
+                           ?max_results: ::Integer
+                         ) -> _GetVariablesResponseSuccess
+                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetVariablesResponseSuccess
+
+      interface _ListEventPredictionsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::ListEventPredictionsResult]
+        def event_prediction_summaries: () -> ::Array[Types::EventPredictionSummary]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#list_event_predictions-instance_method
+      def list_event_predictions: (
+                                    ?event_id: {
+                                      value: ::String?
+                                    },
+                                    ?event_type: {
+                                      value: ::String?
+                                    },
+                                    ?detector_id: {
+                                      value: ::String?
+                                    },
+                                    ?detector_version_id: {
+                                      value: ::String?
+                                    },
+                                    ?prediction_time_range: {
+                                      start_time: ::String,
+                                      end_time: ::String
+                                    },
+                                    ?next_token: ::String,
+                                    ?max_results: ::Integer
+                                  ) -> _ListEventPredictionsResponseSuccess
+                                | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListEventPredictionsResponseSuccess
+
+      interface _ListTagsForResourceResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::ListTagsForResourceResult]
+        def tags: () -> ::Array[Types::Tag]
+        def next_token: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#list_tags_for_resource-instance_method
+      def list_tags_for_resource: (
+                                    resource_arn: ::String,
+                                    ?next_token: ::String,
+                                    ?max_results: ::Integer
+                                  ) -> _ListTagsForResourceResponseSuccess
+                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTagsForResourceResponseSuccess
+
+      interface _PutDetectorResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutDetectorResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_detector-instance_method
+      def put_detector: (
+                          detector_id: ::String,
+                          ?description: ::String,
+                          event_type_name: ::String,
+                          ?tags: Array[
+                            {
+                              key: ::String,
+                              value: ::String
+                            },
+                          ]
+                        ) -> _PutDetectorResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutDetectorResponseSuccess
+
+      interface _PutEntityTypeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutEntityTypeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_entity_type-instance_method
+      def put_entity_type: (
+                             name: ::String,
+                             ?description: ::String,
+                             ?tags: Array[
+                               {
+                                 key: ::String,
+                                 value: ::String
+                               },
+                             ]
+                           ) -> _PutEntityTypeResponseSuccess
+                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutEntityTypeResponseSuccess
+
+      interface _PutEventTypeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutEventTypeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_event_type-instance_method
+      def put_event_type: (
+                            name: ::String,
+                            ?description: ::String,
+                            event_variables: Array[::String],
+                            ?labels: Array[::String],
+                            entity_types: Array[::String],
+                            ?event_ingestion: ("ENABLED" | "DISABLED"),
+                            ?tags: Array[
+                              {
+                                key: ::String,
+                                value: ::String
+                              },
+                            ],
+                            ?event_orchestration: {
+                              event_bridge_enabled: bool
+                            }
+                          ) -> _PutEventTypeResponseSuccess
+                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutEventTypeResponseSuccess
+
+      interface _PutExternalModelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutExternalModelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_external_model-instance_method
+      def put_external_model: (
+                                model_endpoint: ::String,
+                                model_source: ("SAGEMAKER"),
+                                invoke_model_endpoint_role_arn: ::String,
+                                input_configuration: {
+                                  event_type_name: ::String?,
+                                  format: ("TEXT_CSV" | "APPLICATION_JSON")?,
+                                  use_event_variables: bool,
+                                  json_input_template: ::String?,
+                                  csv_input_template: ::String?
+                                },
+                                output_configuration: {
+                                  format: ("TEXT_CSV" | "APPLICATION_JSONLINES"),
+                                  json_key_to_variable_map: Hash[::String, ::String]?,
+                                  csv_index_to_variable_map: Hash[::String, ::String]?
+                                },
+                                model_endpoint_status: ("ASSOCIATED" | "DISSOCIATED"),
+                                ?tags: Array[
+                                  {
+                                    key: ::String,
+                                    value: ::String
+                                  },
+                                ]
+                              ) -> _PutExternalModelResponseSuccess
+                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutExternalModelResponseSuccess
+
+      interface _PutKMSEncryptionKeyResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutKMSEncryptionKeyResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_kms_encryption_key-instance_method
+      def put_kms_encryption_key: (
+                                    kms_encryption_key_arn: ::String
+                                  ) -> _PutKMSEncryptionKeyResponseSuccess
+                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutKMSEncryptionKeyResponseSuccess
+
+      interface _PutLabelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutLabelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_label-instance_method
+      def put_label: (
+                       name: ::String,
+                       ?description: ::String,
+                       ?tags: Array[
+                         {
+                           key: ::String,
+                           value: ::String
+                         },
+                       ]
+                     ) -> _PutLabelResponseSuccess
+                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutLabelResponseSuccess
+
+      interface _PutOutcomeResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::PutOutcomeResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#put_outcome-instance_method
+      def put_outcome: (
+                         name: ::String,
+                         ?description: ::String,
+                         ?tags: Array[
+                           {
+                             key: ::String,
+                             value: ::String
+                           },
+                         ]
+                       ) -> _PutOutcomeResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PutOutcomeResponseSuccess
+
+      interface _SendEventResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::SendEventResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#send_event-instance_method
+      def send_event: (
+                        event_id: ::String,
+                        event_type_name: ::String,
+                        event_timestamp: ::String,
+                        event_variables: Hash[::String, ::String],
+                        ?assigned_label: ::String,
+                        ?label_timestamp: ::String,
+                        entities: Array[
+                          {
+                            entity_type: ::String,
+                            entity_id: ::String
+                          },
+                        ]
+                      ) -> _SendEventResponseSuccess
+                    | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SendEventResponseSuccess
+
+      interface _TagResourceResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::TagResourceResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#tag_resource-instance_method
+      def tag_resource: (
+                          resource_arn: ::String,
+                          tags: Array[
+                            {
+                              key: ::String,
+                              value: ::String
+                            },
+                          ]
+                        ) -> _TagResourceResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TagResourceResponseSuccess
+
+      interface _UntagResourceResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UntagResourceResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#untag_resource-instance_method
+      def untag_resource: (
+                            resource_arn: ::String,
+                            tag_keys: Array[::String]
+                          ) -> _UntagResourceResponseSuccess
+                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UntagResourceResponseSuccess
+
+      interface _UpdateDetectorVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDetectorVersionResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_detector_version-instance_method
+      def update_detector_version: (
+                                     detector_id: ::String,
+                                     detector_version_id: ::String,
+                                     external_model_endpoints: Array[::String],
+                                     rules: Array[
+                                       {
+                                         detector_id: ::String,
+                                         rule_id: ::String,
+                                         rule_version: ::String
+                                       },
+                                     ],
+                                     ?description: ::String,
+                                     ?model_versions: Array[
+                                       {
+                                         model_id: ::String,
+                                         model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                         model_version_number: ::String,
+                                         arn: ::String?
+                                       },
+                                     ],
+                                     ?rule_execution_mode: ("ALL_MATCHED" | "FIRST_MATCHED")
+                                   ) -> _UpdateDetectorVersionResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDetectorVersionResponseSuccess
+
+      interface _UpdateDetectorVersionMetadataResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDetectorVersionMetadataResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_detector_version_metadata-instance_method
+      def update_detector_version_metadata: (
+                                              detector_id: ::String,
+                                              detector_version_id: ::String,
+                                              description: ::String
+                                            ) -> _UpdateDetectorVersionMetadataResponseSuccess
+                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDetectorVersionMetadataResponseSuccess
+
+      interface _UpdateDetectorVersionStatusResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDetectorVersionStatusResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_detector_version_status-instance_method
+      def update_detector_version_status: (
+                                            detector_id: ::String,
+                                            detector_version_id: ::String,
+                                            status: ("DRAFT" | "ACTIVE" | "INACTIVE")
+                                          ) -> _UpdateDetectorVersionStatusResponseSuccess
+                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDetectorVersionStatusResponseSuccess
+
+      interface _UpdateEventLabelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateEventLabelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_event_label-instance_method
+      def update_event_label: (
+                                event_id: ::String,
+                                event_type_name: ::String,
+                                assigned_label: ::String,
+                                label_timestamp: ::String
+                              ) -> _UpdateEventLabelResponseSuccess
+                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateEventLabelResponseSuccess
+
+      interface _UpdateListResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateListResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_list-instance_method
+      def update_list: (
+                         name: ::String,
+                         ?elements: Array[::String],
+                         ?description: ::String,
+                         ?update_mode: ("REPLACE" | "APPEND" | "REMOVE"),
+                         ?variable_type: ::String
+                       ) -> _UpdateListResponseSuccess
+                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateListResponseSuccess
+
+      interface _UpdateModelResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateModelResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_model-instance_method
+      def update_model: (
+                          model_id: ::String,
+                          model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                          ?description: ::String
+                        ) -> _UpdateModelResponseSuccess
+                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateModelResponseSuccess
+
+      interface _UpdateModelVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateModelVersionResult]
+        def model_id: () -> ::String
+        def model_type: () -> ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS")
+        def model_version_number: () -> ::String
+        def status: () -> ::String
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_model_version-instance_method
+      def update_model_version: (
+                                  model_id: ::String,
+                                  model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                  major_version_number: ::String,
+                                  ?external_events_detail: {
+                                    data_location: ::String,
+                                    data_access_role_arn: ::String
+                                  },
+                                  ?ingested_events_detail: {
+                                    ingested_events_time_window: {
+                                      start_time: ::String,
+                                      end_time: ::String
+                                    }
+                                  },
+                                  ?tags: Array[
+                                    {
+                                      key: ::String,
+                                      value: ::String
+                                    },
+                                  ]
+                                ) -> _UpdateModelVersionResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateModelVersionResponseSuccess
+
+      interface _UpdateModelVersionStatusResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateModelVersionStatusResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_model_version_status-instance_method
+      def update_model_version_status: (
+                                         model_id: ::String,
+                                         model_type: ("ONLINE_FRAUD_INSIGHTS" | "TRANSACTION_FRAUD_INSIGHTS" | "ACCOUNT_TAKEOVER_INSIGHTS"),
+                                         model_version_number: ::String,
+                                         status: ("ACTIVE" | "INACTIVE" | "TRAINING_CANCELLED")
+                                       ) -> _UpdateModelVersionStatusResponseSuccess
+                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateModelVersionStatusResponseSuccess
+
+      interface _UpdateRuleMetadataResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateRuleMetadataResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_rule_metadata-instance_method
+      def update_rule_metadata: (
+                                  rule: {
+                                    detector_id: ::String,
+                                    rule_id: ::String,
+                                    rule_version: ::String
+                                  },
+                                  description: ::String
+                                ) -> _UpdateRuleMetadataResponseSuccess
+                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateRuleMetadataResponseSuccess
+
+      interface _UpdateRuleVersionResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateRuleVersionResult]
+        def rule: () -> Types::Rule
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_rule_version-instance_method
+      def update_rule_version: (
+                                 rule: {
+                                   detector_id: ::String,
+                                   rule_id: ::String,
+                                   rule_version: ::String
+                                 },
+                                 ?description: ::String,
+                                 expression: ::String,
+                                 language: ("DETECTORPL"),
+                                 outcomes: Array[::String],
+                                 ?tags: Array[
+                                   {
+                                     key: ::String,
+                                     value: ::String
+                                   },
+                                 ]
+                               ) -> _UpdateRuleVersionResponseSuccess
+                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateRuleVersionResponseSuccess
+
+      interface _UpdateVariableResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateVariableResult]
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/FraudDetector/Client.html#update_variable-instance_method
+      def update_variable: (
+                             name: ::String,
+                             ?default_value: ::String,
+                             ?description: ::String,
+                             ?variable_type: ::String
+                           ) -> _UpdateVariableResponseSuccess
+                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateVariableResponseSuccess
+    end
+  end
+end
+