@aws-sdk/client-frauddetector 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2416 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare enum AsyncJobStatus {
+    CANCELED = "CANCELED",
+    CANCEL_IN_PROGRESS = "CANCEL_IN_PROGRESS",
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    IN_PROGRESS_INITIALIZING = "IN_PROGRESS_INITIALIZING"
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface VariableEntry {
+    
+    name?: string;
+    
+    dataType?: string;
+    
+    dataSource?: string;
+    
+    defaultValue?: string;
+    
+    description?: string;
+    
+    variableType?: string;
+}
+export declare namespace VariableEntry {
+    
+    const filterSensitiveLog: (obj: VariableEntry) => any;
+}
+export interface BatchCreateVariableRequest {
+    
+    variableEntries: VariableEntry[] | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace BatchCreateVariableRequest {
+    
+    const filterSensitiveLog: (obj: BatchCreateVariableRequest) => any;
+}
+
+export interface BatchCreateVariableError {
+    
+    name?: string;
+    
+    code?: number;
+    
+    message?: string;
+}
+export declare namespace BatchCreateVariableError {
+    
+    const filterSensitiveLog: (obj: BatchCreateVariableError) => any;
+}
+export interface BatchCreateVariableResult {
+    
+    errors?: BatchCreateVariableError[];
+}
+export declare namespace BatchCreateVariableResult {
+    
+    const filterSensitiveLog: (obj: BatchCreateVariableResult) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    message: string | undefined;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    message: string | undefined;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message: string | undefined;
+}
+export interface BatchGetVariableRequest {
+    
+    names: string[] | undefined;
+}
+export declare namespace BatchGetVariableRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetVariableRequest) => any;
+}
+
+export interface BatchGetVariableError {
+    
+    name?: string;
+    
+    code?: number;
+    
+    message?: string;
+}
+export declare namespace BatchGetVariableError {
+    
+    const filterSensitiveLog: (obj: BatchGetVariableError) => any;
+}
+export declare enum DataSource {
+    EVENT = "EVENT",
+    EXTERNAL_MODEL_SCORE = "EXTERNAL_MODEL_SCORE",
+    MODEL_SCORE = "MODEL_SCORE"
+}
+export declare enum DataType {
+    BOOLEAN = "BOOLEAN",
+    FLOAT = "FLOAT",
+    INTEGER = "INTEGER",
+    STRING = "STRING"
+}
+
+export interface Variable {
+    
+    name?: string;
+    
+    dataType?: DataType | string;
+    
+    dataSource?: DataSource | string;
+    
+    defaultValue?: string;
+    
+    description?: string;
+    
+    variableType?: string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace Variable {
+    
+    const filterSensitiveLog: (obj: Variable) => any;
+}
+export interface BatchGetVariableResult {
+    
+    variables?: Variable[];
+    
+    errors?: BatchGetVariableError[];
+}
+export declare namespace BatchGetVariableResult {
+    
+    const filterSensitiveLog: (obj: BatchGetVariableResult) => any;
+}
+export interface CancelBatchImportJobRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace CancelBatchImportJobRequest {
+    
+    const filterSensitiveLog: (obj: CancelBatchImportJobRequest) => any;
+}
+export interface CancelBatchImportJobResult {
+}
+export declare namespace CancelBatchImportJobResult {
+    
+    const filterSensitiveLog: (obj: CancelBatchImportJobResult) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message: string | undefined;
+}
+export interface CancelBatchPredictionJobRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace CancelBatchPredictionJobRequest {
+    
+    const filterSensitiveLog: (obj: CancelBatchPredictionJobRequest) => any;
+}
+export interface CancelBatchPredictionJobResult {
+}
+export declare namespace CancelBatchPredictionJobResult {
+    
+    const filterSensitiveLog: (obj: CancelBatchPredictionJobResult) => any;
+}
+export interface CreateBatchImportJobRequest {
+    
+    jobId: string | undefined;
+    
+    inputPath: string | undefined;
+    
+    outputPath: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    iamRoleArn: string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateBatchImportJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateBatchImportJobRequest) => any;
+}
+export interface CreateBatchImportJobResult {
+}
+export declare namespace CreateBatchImportJobResult {
+    
+    const filterSensitiveLog: (obj: CreateBatchImportJobResult) => any;
+}
+export interface CreateBatchPredictionJobRequest {
+    
+    jobId: string | undefined;
+    
+    inputPath: string | undefined;
+    
+    outputPath: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    detectorName: string | undefined;
+    
+    detectorVersion?: string;
+    
+    iamRoleArn: string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateBatchPredictionJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateBatchPredictionJobRequest) => any;
+}
+export interface CreateBatchPredictionJobResult {
+}
+export declare namespace CreateBatchPredictionJobResult {
+    
+    const filterSensitiveLog: (obj: CreateBatchPredictionJobResult) => any;
+}
+export declare enum ModelTypeEnum {
+    ONLINE_FRAUD_INSIGHTS = "ONLINE_FRAUD_INSIGHTS",
+    TRANSACTION_FRAUD_INSIGHTS = "TRANSACTION_FRAUD_INSIGHTS"
+}
+
+export interface ModelVersion {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    modelVersionNumber: string | undefined;
+    
+    arn?: string;
+}
+export declare namespace ModelVersion {
+    
+    const filterSensitiveLog: (obj: ModelVersion) => any;
+}
+export declare enum RuleExecutionMode {
+    ALL_MATCHED = "ALL_MATCHED",
+    FIRST_MATCHED = "FIRST_MATCHED"
+}
+
+export interface Rule {
+    
+    detectorId: string | undefined;
+    
+    ruleId: string | undefined;
+    
+    ruleVersion: string | undefined;
+}
+export declare namespace Rule {
+    
+    const filterSensitiveLog: (obj: Rule) => any;
+}
+export interface CreateDetectorVersionRequest {
+    
+    detectorId: string | undefined;
+    
+    description?: string;
+    
+    externalModelEndpoints?: string[];
+    
+    rules: Rule[] | undefined;
+    
+    modelVersions?: ModelVersion[];
+    
+    ruleExecutionMode?: RuleExecutionMode | string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateDetectorVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateDetectorVersionRequest) => any;
+}
+export declare enum DetectorVersionStatus {
+    ACTIVE = "ACTIVE",
+    DRAFT = "DRAFT",
+    INACTIVE = "INACTIVE"
+}
+export interface CreateDetectorVersionResult {
+    
+    detectorId?: string;
+    
+    detectorVersionId?: string;
+    
+    status?: DetectorVersionStatus | string;
+}
+export declare namespace CreateDetectorVersionResult {
+    
+    const filterSensitiveLog: (obj: CreateDetectorVersionResult) => any;
+}
+export interface CreateModelRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    description?: string;
+    
+    eventTypeName: string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateModelRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelRequest) => any;
+}
+export interface CreateModelResult {
+}
+export declare namespace CreateModelResult {
+    
+    const filterSensitiveLog: (obj: CreateModelResult) => any;
+}
+
+export interface ExternalEventsDetail {
+    
+    dataLocation: string | undefined;
+    
+    dataAccessRoleArn: string | undefined;
+}
+export declare namespace ExternalEventsDetail {
+    
+    const filterSensitiveLog: (obj: ExternalEventsDetail) => any;
+}
+
+export interface IngestedEventsTimeWindow {
+    
+    startTime: string | undefined;
+    
+    endTime: string | undefined;
+}
+export declare namespace IngestedEventsTimeWindow {
+    
+    const filterSensitiveLog: (obj: IngestedEventsTimeWindow) => any;
+}
+
+export interface IngestedEventsDetail {
+    
+    ingestedEventsTimeWindow: IngestedEventsTimeWindow | undefined;
+}
+export declare namespace IngestedEventsDetail {
+    
+    const filterSensitiveLog: (obj: IngestedEventsDetail) => any;
+}
+export declare enum UnlabeledEventsTreatment {
+    FRAUD = "FRAUD",
+    IGNORE = "IGNORE",
+    LEGIT = "LEGIT"
+}
+
+export interface LabelSchema {
+    
+    labelMapper: {
+        [key: string]: string[];
+    } | undefined;
+    
+    unlabeledEventsTreatment?: UnlabeledEventsTreatment | string;
+}
+export declare namespace LabelSchema {
+    
+    const filterSensitiveLog: (obj: LabelSchema) => any;
+}
+
+export interface TrainingDataSchema {
+    
+    modelVariables: string[] | undefined;
+    
+    labelSchema: LabelSchema | undefined;
+}
+export declare namespace TrainingDataSchema {
+    
+    const filterSensitiveLog: (obj: TrainingDataSchema) => any;
+}
+export declare enum TrainingDataSourceEnum {
+    EXTERNAL_EVENTS = "EXTERNAL_EVENTS",
+    INGESTED_EVENTS = "INGESTED_EVENTS"
+}
+export interface CreateModelVersionRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    trainingDataSource: TrainingDataSourceEnum | string | undefined;
+    
+    trainingDataSchema: TrainingDataSchema | undefined;
+    
+    externalEventsDetail?: ExternalEventsDetail;
+    
+    ingestedEventsDetail?: IngestedEventsDetail;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateModelVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelVersionRequest) => any;
+}
+export interface CreateModelVersionResult {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    modelVersionNumber?: string;
+    
+    status?: string;
+}
+export declare namespace CreateModelVersionResult {
+    
+    const filterSensitiveLog: (obj: CreateModelVersionResult) => any;
+}
+export declare enum Language {
+    DETECTORPL = "DETECTORPL"
+}
+export interface CreateRuleRequest {
+    
+    ruleId: string | undefined;
+    
+    detectorId: string | undefined;
+    
+    description?: string;
+    
+    expression: string | undefined;
+    
+    language: Language | string | undefined;
+    
+    outcomes: string[] | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateRuleRequest {
+    
+    const filterSensitiveLog: (obj: CreateRuleRequest) => any;
+}
+export interface CreateRuleResult {
+    
+    rule?: Rule;
+}
+export declare namespace CreateRuleResult {
+    
+    const filterSensitiveLog: (obj: CreateRuleResult) => any;
+}
+export interface CreateVariableRequest {
+    
+    name: string | undefined;
+    
+    dataType: DataType | string | undefined;
+    
+    dataSource: DataSource | string | undefined;
+    
+    defaultValue: string | undefined;
+    
+    description?: string;
+    
+    variableType?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateVariableRequest {
+    
+    const filterSensitiveLog: (obj: CreateVariableRequest) => any;
+}
+export interface CreateVariableResult {
+}
+export declare namespace CreateVariableResult {
+    
+    const filterSensitiveLog: (obj: CreateVariableResult) => any;
+}
+export interface DeleteBatchImportJobRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace DeleteBatchImportJobRequest {
+    
+    const filterSensitiveLog: (obj: DeleteBatchImportJobRequest) => any;
+}
+export interface DeleteBatchImportJobResult {
+}
+export declare namespace DeleteBatchImportJobResult {
+    
+    const filterSensitiveLog: (obj: DeleteBatchImportJobResult) => any;
+}
+export interface DeleteBatchPredictionJobRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace DeleteBatchPredictionJobRequest {
+    
+    const filterSensitiveLog: (obj: DeleteBatchPredictionJobRequest) => any;
+}
+export interface DeleteBatchPredictionJobResult {
+}
+export declare namespace DeleteBatchPredictionJobResult {
+    
+    const filterSensitiveLog: (obj: DeleteBatchPredictionJobResult) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message: string | undefined;
+}
+export interface DeleteDetectorRequest {
+    
+    detectorId: string | undefined;
+}
+export declare namespace DeleteDetectorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDetectorRequest) => any;
+}
+export interface DeleteDetectorResult {
+}
+export declare namespace DeleteDetectorResult {
+    
+    const filterSensitiveLog: (obj: DeleteDetectorResult) => any;
+}
+export interface DeleteDetectorVersionRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+}
+export declare namespace DeleteDetectorVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDetectorVersionRequest) => any;
+}
+export interface DeleteDetectorVersionResult {
+}
+export declare namespace DeleteDetectorVersionResult {
+    
+    const filterSensitiveLog: (obj: DeleteDetectorVersionResult) => any;
+}
+export interface DeleteEntityTypeRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteEntityTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEntityTypeRequest) => any;
+}
+export interface DeleteEntityTypeResult {
+}
+export declare namespace DeleteEntityTypeResult {
+    
+    const filterSensitiveLog: (obj: DeleteEntityTypeResult) => any;
+}
+export interface DeleteEventRequest {
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    deleteAuditHistory?: boolean;
+}
+export declare namespace DeleteEventRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventRequest) => any;
+}
+export interface DeleteEventResult {
+}
+export declare namespace DeleteEventResult {
+    
+    const filterSensitiveLog: (obj: DeleteEventResult) => any;
+}
+export interface DeleteEventsByEventTypeRequest {
+    
+    eventTypeName: string | undefined;
+}
+export declare namespace DeleteEventsByEventTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventsByEventTypeRequest) => any;
+}
+export interface DeleteEventsByEventTypeResult {
+    
+    eventTypeName?: string;
+    
+    eventsDeletionStatus?: string;
+}
+export declare namespace DeleteEventsByEventTypeResult {
+    
+    const filterSensitiveLog: (obj: DeleteEventsByEventTypeResult) => any;
+}
+export interface DeleteEventTypeRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteEventTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventTypeRequest) => any;
+}
+export interface DeleteEventTypeResult {
+}
+export declare namespace DeleteEventTypeResult {
+    
+    const filterSensitiveLog: (obj: DeleteEventTypeResult) => any;
+}
+export interface DeleteExternalModelRequest {
+    
+    modelEndpoint: string | undefined;
+}
+export declare namespace DeleteExternalModelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteExternalModelRequest) => any;
+}
+export interface DeleteExternalModelResult {
+}
+export declare namespace DeleteExternalModelResult {
+    
+    const filterSensitiveLog: (obj: DeleteExternalModelResult) => any;
+}
+export interface DeleteLabelRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteLabelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLabelRequest) => any;
+}
+export interface DeleteLabelResult {
+}
+export declare namespace DeleteLabelResult {
+    
+    const filterSensitiveLog: (obj: DeleteLabelResult) => any;
+}
+export interface DeleteModelRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+}
+export declare namespace DeleteModelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelRequest) => any;
+}
+export interface DeleteModelResult {
+}
+export declare namespace DeleteModelResult {
+    
+    const filterSensitiveLog: (obj: DeleteModelResult) => any;
+}
+export interface DeleteModelVersionRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    modelVersionNumber: string | undefined;
+}
+export declare namespace DeleteModelVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelVersionRequest) => any;
+}
+export interface DeleteModelVersionResult {
+}
+export declare namespace DeleteModelVersionResult {
+    
+    const filterSensitiveLog: (obj: DeleteModelVersionResult) => any;
+}
+export interface DeleteOutcomeRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteOutcomeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteOutcomeRequest) => any;
+}
+export interface DeleteOutcomeResult {
+}
+export declare namespace DeleteOutcomeResult {
+    
+    const filterSensitiveLog: (obj: DeleteOutcomeResult) => any;
+}
+export interface DeleteRuleRequest {
+    
+    rule: Rule | undefined;
+}
+export declare namespace DeleteRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRuleRequest) => any;
+}
+export interface DeleteRuleResult {
+}
+export declare namespace DeleteRuleResult {
+    
+    const filterSensitiveLog: (obj: DeleteRuleResult) => any;
+}
+export interface DeleteVariableRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteVariableRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVariableRequest) => any;
+}
+export interface DeleteVariableResult {
+}
+export declare namespace DeleteVariableResult {
+    
+    const filterSensitiveLog: (obj: DeleteVariableResult) => any;
+}
+export interface DescribeDetectorRequest {
+    
+    detectorId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeDetectorRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDetectorRequest) => any;
+}
+
+export interface DetectorVersionSummary {
+    
+    detectorVersionId?: string;
+    
+    status?: DetectorVersionStatus | string;
+    
+    description?: string;
+    
+    lastUpdatedTime?: string;
+}
+export declare namespace DetectorVersionSummary {
+    
+    const filterSensitiveLog: (obj: DetectorVersionSummary) => any;
+}
+export interface DescribeDetectorResult {
+    
+    detectorId?: string;
+    
+    detectorVersionSummaries?: DetectorVersionSummary[];
+    
+    nextToken?: string;
+    
+    arn?: string;
+}
+export declare namespace DescribeDetectorResult {
+    
+    const filterSensitiveLog: (obj: DescribeDetectorResult) => any;
+}
+export interface DescribeModelVersionsRequest {
+    
+    modelId?: string;
+    
+    modelVersionNumber?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeModelVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeModelVersionsRequest) => any;
+}
+
+export interface FieldValidationMessage {
+    
+    fieldName?: string;
+    
+    identifier?: string;
+    
+    title?: string;
+    
+    content?: string;
+    
+    type?: string;
+}
+export declare namespace FieldValidationMessage {
+    
+    const filterSensitiveLog: (obj: FieldValidationMessage) => any;
+}
+
+export interface FileValidationMessage {
+    
+    title?: string;
+    
+    content?: string;
+    
+    type?: string;
+}
+export declare namespace FileValidationMessage {
+    
+    const filterSensitiveLog: (obj: FileValidationMessage) => any;
+}
+
+export interface DataValidationMetrics {
+    
+    fileLevelMessages?: FileValidationMessage[];
+    
+    fieldLevelMessages?: FieldValidationMessage[];
+}
+export declare namespace DataValidationMetrics {
+    
+    const filterSensitiveLog: (obj: DataValidationMetrics) => any;
+}
+
+export interface MetricDataPoint {
+    
+    fpr?: number;
+    
+    precision?: number;
+    
+    tpr?: number;
+    
+    threshold?: number;
+}
+export declare namespace MetricDataPoint {
+    
+    const filterSensitiveLog: (obj: MetricDataPoint) => any;
+}
+
+export interface TrainingMetrics {
+    
+    auc?: number;
+    
+    metricDataPoints?: MetricDataPoint[];
+}
+export declare namespace TrainingMetrics {
+    
+    const filterSensitiveLog: (obj: TrainingMetrics) => any;
+}
+
+export interface LogOddsMetric {
+    
+    variableName: string | undefined;
+    
+    variableType: string | undefined;
+    
+    variableImportance: number | undefined;
+}
+export declare namespace LogOddsMetric {
+    
+    const filterSensitiveLog: (obj: LogOddsMetric) => any;
+}
+
+export interface VariableImportanceMetrics {
+    
+    logOddsMetrics?: LogOddsMetric[];
+}
+export declare namespace VariableImportanceMetrics {
+    
+    const filterSensitiveLog: (obj: VariableImportanceMetrics) => any;
+}
+
+export interface TrainingResult {
+    
+    dataValidationMetrics?: DataValidationMetrics;
+    
+    trainingMetrics?: TrainingMetrics;
+    
+    variableImportanceMetrics?: VariableImportanceMetrics;
+}
+export declare namespace TrainingResult {
+    
+    const filterSensitiveLog: (obj: TrainingResult) => any;
+}
+
+export interface ModelVersionDetail {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    modelVersionNumber?: string;
+    
+    status?: string;
+    
+    trainingDataSource?: TrainingDataSourceEnum | string;
+    
+    trainingDataSchema?: TrainingDataSchema;
+    
+    externalEventsDetail?: ExternalEventsDetail;
+    
+    ingestedEventsDetail?: IngestedEventsDetail;
+    
+    trainingResult?: TrainingResult;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace ModelVersionDetail {
+    
+    const filterSensitiveLog: (obj: ModelVersionDetail) => any;
+}
+export interface DescribeModelVersionsResult {
+    
+    modelVersionDetails?: ModelVersionDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeModelVersionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeModelVersionsResult) => any;
+}
+export interface GetBatchImportJobsRequest {
+    
+    jobId?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace GetBatchImportJobsRequest {
+    
+    const filterSensitiveLog: (obj: GetBatchImportJobsRequest) => any;
+}
+
+export interface BatchImport {
+    
+    jobId?: string;
+    
+    status?: AsyncJobStatus | string;
+    
+    failureReason?: string;
+    
+    startTime?: string;
+    
+    completionTime?: string;
+    
+    inputPath?: string;
+    
+    outputPath?: string;
+    
+    eventTypeName?: string;
+    
+    iamRoleArn?: string;
+    
+    arn?: string;
+    
+    processedRecordsCount?: number;
+    
+    failedRecordsCount?: number;
+    
+    totalRecordsCount?: number;
+}
+export declare namespace BatchImport {
+    
+    const filterSensitiveLog: (obj: BatchImport) => any;
+}
+export interface GetBatchImportJobsResult {
+    
+    batchImports?: BatchImport[];
+    
+    nextToken?: string;
+}
+export declare namespace GetBatchImportJobsResult {
+    
+    const filterSensitiveLog: (obj: GetBatchImportJobsResult) => any;
+}
+export interface GetBatchPredictionJobsRequest {
+    
+    jobId?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace GetBatchPredictionJobsRequest {
+    
+    const filterSensitiveLog: (obj: GetBatchPredictionJobsRequest) => any;
+}
+
+export interface BatchPrediction {
+    
+    jobId?: string;
+    
+    status?: AsyncJobStatus | string;
+    
+    failureReason?: string;
+    
+    startTime?: string;
+    
+    completionTime?: string;
+    
+    lastHeartbeatTime?: string;
+    
+    inputPath?: string;
+    
+    outputPath?: string;
+    
+    eventTypeName?: string;
+    
+    detectorName?: string;
+    
+    detectorVersion?: string;
+    
+    iamRoleArn?: string;
+    
+    arn?: string;
+    
+    processedRecordsCount?: number;
+    
+    totalRecordsCount?: number;
+}
+export declare namespace BatchPrediction {
+    
+    const filterSensitiveLog: (obj: BatchPrediction) => any;
+}
+export interface GetBatchPredictionJobsResult {
+    
+    batchPredictions?: BatchPrediction[];
+    
+    nextToken?: string;
+}
+export declare namespace GetBatchPredictionJobsResult {
+    
+    const filterSensitiveLog: (obj: GetBatchPredictionJobsResult) => any;
+}
+export interface GetDeleteEventsByEventTypeStatusRequest {
+    
+    eventTypeName: string | undefined;
+}
+export declare namespace GetDeleteEventsByEventTypeStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetDeleteEventsByEventTypeStatusRequest) => any;
+}
+export interface GetDeleteEventsByEventTypeStatusResult {
+    
+    eventTypeName?: string;
+    
+    eventsDeletionStatus?: AsyncJobStatus | string;
+}
+export declare namespace GetDeleteEventsByEventTypeStatusResult {
+    
+    const filterSensitiveLog: (obj: GetDeleteEventsByEventTypeStatusResult) => any;
+}
+export interface GetDetectorsRequest {
+    
+    detectorId?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetDetectorsRequest {
+    
+    const filterSensitiveLog: (obj: GetDetectorsRequest) => any;
+}
+
+export interface Detector {
+    
+    detectorId?: string;
+    
+    description?: string;
+    
+    eventTypeName?: string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace Detector {
+    
+    const filterSensitiveLog: (obj: Detector) => any;
+}
+export interface GetDetectorsResult {
+    
+    detectors?: Detector[];
+    
+    nextToken?: string;
+}
+export declare namespace GetDetectorsResult {
+    
+    const filterSensitiveLog: (obj: GetDetectorsResult) => any;
+}
+export interface GetDetectorVersionRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+}
+export declare namespace GetDetectorVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetDetectorVersionRequest) => any;
+}
+export interface GetDetectorVersionResult {
+    
+    detectorId?: string;
+    
+    detectorVersionId?: string;
+    
+    description?: string;
+    
+    externalModelEndpoints?: string[];
+    
+    modelVersions?: ModelVersion[];
+    
+    rules?: Rule[];
+    
+    status?: DetectorVersionStatus | string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    ruleExecutionMode?: RuleExecutionMode | string;
+    
+    arn?: string;
+}
+export declare namespace GetDetectorVersionResult {
+    
+    const filterSensitiveLog: (obj: GetDetectorVersionResult) => any;
+}
+export interface GetEntityTypesRequest {
+    
+    name?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetEntityTypesRequest {
+    
+    const filterSensitiveLog: (obj: GetEntityTypesRequest) => any;
+}
+
+export interface EntityType {
+    
+    name?: string;
+    
+    description?: string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace EntityType {
+    
+    const filterSensitiveLog: (obj: EntityType) => any;
+}
+export interface GetEntityTypesResult {
+    
+    entityTypes?: EntityType[];
+    
+    nextToken?: string;
+}
+export declare namespace GetEntityTypesResult {
+    
+    const filterSensitiveLog: (obj: GetEntityTypesResult) => any;
+}
+export interface GetEventRequest {
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+}
+export declare namespace GetEventRequest {
+    
+    const filterSensitiveLog: (obj: GetEventRequest) => any;
+}
+
+export interface Entity {
+    
+    entityType: string | undefined;
+    
+    entityId: string | undefined;
+}
+export declare namespace Entity {
+    
+    const filterSensitiveLog: (obj: Entity) => any;
+}
+
+export interface Event {
+    
+    eventId?: string;
+    
+    eventTypeName?: string;
+    
+    eventTimestamp?: string;
+    
+    eventVariables?: {
+        [key: string]: string;
+    };
+    
+    currentLabel?: string;
+    
+    labelTimestamp?: string;
+    
+    entities?: Entity[];
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+export interface GetEventResult {
+    
+    event?: Event;
+}
+export declare namespace GetEventResult {
+    
+    const filterSensitiveLog: (obj: GetEventResult) => any;
+}
+
+export interface ModelEndpointDataBlob {
+    
+    byteBuffer?: Uint8Array;
+    
+    contentType?: string;
+}
+export declare namespace ModelEndpointDataBlob {
+    
+    const filterSensitiveLog: (obj: ModelEndpointDataBlob) => any;
+}
+export interface GetEventPredictionRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId?: string;
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    entities: Entity[] | undefined;
+    
+    eventTimestamp: string | undefined;
+    
+    eventVariables: {
+        [key: string]: string;
+    } | undefined;
+    
+    externalModelEndpointDataBlobs?: {
+        [key: string]: ModelEndpointDataBlob;
+    };
+}
+export declare namespace GetEventPredictionRequest {
+    
+    const filterSensitiveLog: (obj: GetEventPredictionRequest) => any;
+}
+export declare enum ModelSource {
+    SAGEMAKER = "SAGEMAKER"
+}
+
+export interface ExternalModelSummary {
+    
+    modelEndpoint?: string;
+    
+    modelSource?: ModelSource | string;
+}
+export declare namespace ExternalModelSummary {
+    
+    const filterSensitiveLog: (obj: ExternalModelSummary) => any;
+}
+
+export interface ExternalModelOutputs {
+    
+    externalModel?: ExternalModelSummary;
+    
+    outputs?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExternalModelOutputs {
+    
+    const filterSensitiveLog: (obj: ExternalModelOutputs) => any;
+}
+
+export interface ModelScores {
+    
+    modelVersion?: ModelVersion;
+    
+    scores?: {
+        [key: string]: number;
+    };
+}
+export declare namespace ModelScores {
+    
+    const filterSensitiveLog: (obj: ModelScores) => any;
+}
+
+export interface RuleResult {
+    
+    ruleId?: string;
+    
+    outcomes?: string[];
+}
+export declare namespace RuleResult {
+    
+    const filterSensitiveLog: (obj: RuleResult) => any;
+}
+export interface GetEventPredictionResult {
+    
+    modelScores?: ModelScores[];
+    
+    ruleResults?: RuleResult[];
+    
+    externalModelOutputs?: ExternalModelOutputs[];
+}
+export declare namespace GetEventPredictionResult {
+    
+    const filterSensitiveLog: (obj: GetEventPredictionResult) => any;
+}
+
+export interface ResourceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ResourceUnavailableException";
+    $fault: "client";
+    message?: string;
+}
+export interface GetEventPredictionMetadataRequest {
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+    
+    predictionTimestamp: string | undefined;
+}
+export declare namespace GetEventPredictionMetadataRequest {
+    
+    const filterSensitiveLog: (obj: GetEventPredictionMetadataRequest) => any;
+}
+
+export interface EvaluatedExternalModel {
+    
+    modelEndpoint?: string;
+    
+    useEventVariables?: boolean;
+    
+    inputVariables?: {
+        [key: string]: string;
+    };
+    
+    outputVariables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace EvaluatedExternalModel {
+    
+    const filterSensitiveLog: (obj: EvaluatedExternalModel) => any;
+}
+
+export interface VariableImpactExplanation {
+    
+    eventVariableName?: string;
+    
+    relativeImpact?: string;
+    
+    logOddsImpact?: number;
+}
+export declare namespace VariableImpactExplanation {
+    
+    const filterSensitiveLog: (obj: VariableImpactExplanation) => any;
+}
+
+export interface PredictionExplanations {
+    
+    variableImpactExplanations?: VariableImpactExplanation[];
+}
+export declare namespace PredictionExplanations {
+    
+    const filterSensitiveLog: (obj: PredictionExplanations) => any;
+}
+
+export interface ModelVersionEvaluation {
+    
+    outputVariableName?: string;
+    
+    evaluationScore?: string;
+    
+    predictionExplanations?: PredictionExplanations;
+}
+export declare namespace ModelVersionEvaluation {
+    
+    const filterSensitiveLog: (obj: ModelVersionEvaluation) => any;
+}
+
+export interface EvaluatedModelVersion {
+    
+    modelId?: string;
+    
+    modelVersion?: string;
+    
+    modelType?: string;
+    
+    evaluations?: ModelVersionEvaluation[];
+}
+export declare namespace EvaluatedModelVersion {
+    
+    const filterSensitiveLog: (obj: EvaluatedModelVersion) => any;
+}
+
+export interface EventVariableSummary {
+    
+    name?: string;
+    
+    value?: string;
+    
+    source?: string;
+}
+export declare namespace EventVariableSummary {
+    
+    const filterSensitiveLog: (obj: EventVariableSummary) => any;
+}
+
+export interface EvaluatedRule {
+    
+    ruleId?: string;
+    
+    ruleVersion?: string;
+    
+    expression?: string;
+    
+    expressionWithValues?: string;
+    
+    outcomes?: string[];
+    
+    evaluated?: boolean;
+    
+    matched?: boolean;
+}
+export declare namespace EvaluatedRule {
+    
+    const filterSensitiveLog: (obj: EvaluatedRule) => any;
+}
+export interface GetEventPredictionMetadataResult {
+    
+    eventId?: string;
+    
+    eventTypeName?: string;
+    
+    entityId?: string;
+    
+    entityType?: string;
+    
+    eventTimestamp?: string;
+    
+    detectorId?: string;
+    
+    detectorVersionId?: string;
+    
+    detectorVersionStatus?: string;
+    
+    eventVariables?: EventVariableSummary[];
+    
+    rules?: EvaluatedRule[];
+    
+    ruleExecutionMode?: RuleExecutionMode | string;
+    
+    outcomes?: string[];
+    
+    evaluatedModelVersions?: EvaluatedModelVersion[];
+    
+    evaluatedExternalModels?: EvaluatedExternalModel[];
+    
+    predictionTimestamp?: string;
+}
+export declare namespace GetEventPredictionMetadataResult {
+    
+    const filterSensitiveLog: (obj: GetEventPredictionMetadataResult) => any;
+}
+export interface GetEventTypesRequest {
+    
+    name?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetEventTypesRequest {
+    
+    const filterSensitiveLog: (obj: GetEventTypesRequest) => any;
+}
+export declare enum EventIngestion {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface IngestedEventStatistics {
+    
+    numberOfEvents?: number;
+    
+    eventDataSizeInBytes?: number;
+    
+    leastRecentEvent?: string;
+    
+    mostRecentEvent?: string;
+    
+    lastUpdatedTime?: string;
+}
+export declare namespace IngestedEventStatistics {
+    
+    const filterSensitiveLog: (obj: IngestedEventStatistics) => any;
+}
+
+export interface EventType {
+    
+    name?: string;
+    
+    description?: string;
+    
+    eventVariables?: string[];
+    
+    labels?: string[];
+    
+    entityTypes?: string[];
+    
+    eventIngestion?: EventIngestion | string;
+    
+    ingestedEventStatistics?: IngestedEventStatistics;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace EventType {
+    
+    const filterSensitiveLog: (obj: EventType) => any;
+}
+export interface GetEventTypesResult {
+    
+    eventTypes?: EventType[];
+    
+    nextToken?: string;
+}
+export declare namespace GetEventTypesResult {
+    
+    const filterSensitiveLog: (obj: GetEventTypesResult) => any;
+}
+export interface GetExternalModelsRequest {
+    
+    modelEndpoint?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetExternalModelsRequest {
+    
+    const filterSensitiveLog: (obj: GetExternalModelsRequest) => any;
+}
+export declare enum ModelInputDataFormat {
+    CSV = "TEXT_CSV",
+    JSON = "APPLICATION_JSON"
+}
+
+export interface ModelInputConfiguration {
+    
+    eventTypeName?: string;
+    
+    format?: ModelInputDataFormat | string;
+    
+    useEventVariables: boolean | undefined;
+    
+    jsonInputTemplate?: string;
+    
+    csvInputTemplate?: string;
+}
+export declare namespace ModelInputConfiguration {
+    
+    const filterSensitiveLog: (obj: ModelInputConfiguration) => any;
+}
+export declare enum ModelEndpointStatus {
+    ASSOCIATED = "ASSOCIATED",
+    DISSOCIATED = "DISSOCIATED"
+}
+export declare enum ModelOutputDataFormat {
+    CSV = "TEXT_CSV",
+    JSONLINES = "APPLICATION_JSONLINES"
+}
+
+export interface ModelOutputConfiguration {
+    
+    format: ModelOutputDataFormat | string | undefined;
+    
+    jsonKeyToVariableMap?: {
+        [key: string]: string;
+    };
+    
+    csvIndexToVariableMap?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ModelOutputConfiguration {
+    
+    const filterSensitiveLog: (obj: ModelOutputConfiguration) => any;
+}
+
+export interface ExternalModel {
+    
+    modelEndpoint?: string;
+    
+    modelSource?: ModelSource | string;
+    
+    invokeModelEndpointRoleArn?: string;
+    
+    inputConfiguration?: ModelInputConfiguration;
+    
+    outputConfiguration?: ModelOutputConfiguration;
+    
+    modelEndpointStatus?: ModelEndpointStatus | string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace ExternalModel {
+    
+    const filterSensitiveLog: (obj: ExternalModel) => any;
+}
+export interface GetExternalModelsResult {
+    
+    externalModels?: ExternalModel[];
+    
+    nextToken?: string;
+}
+export declare namespace GetExternalModelsResult {
+    
+    const filterSensitiveLog: (obj: GetExternalModelsResult) => any;
+}
+
+export interface KMSKey {
+    
+    kmsEncryptionKeyArn?: string;
+}
+export declare namespace KMSKey {
+    
+    const filterSensitiveLog: (obj: KMSKey) => any;
+}
+export interface GetKMSEncryptionKeyResult {
+    
+    kmsKey?: KMSKey;
+}
+export declare namespace GetKMSEncryptionKeyResult {
+    
+    const filterSensitiveLog: (obj: GetKMSEncryptionKeyResult) => any;
+}
+export interface GetLabelsRequest {
+    
+    name?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetLabelsRequest {
+    
+    const filterSensitiveLog: (obj: GetLabelsRequest) => any;
+}
+
+export interface Label {
+    
+    name?: string;
+    
+    description?: string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace Label {
+    
+    const filterSensitiveLog: (obj: Label) => any;
+}
+export interface GetLabelsResult {
+    
+    labels?: Label[];
+    
+    nextToken?: string;
+}
+export declare namespace GetLabelsResult {
+    
+    const filterSensitiveLog: (obj: GetLabelsResult) => any;
+}
+export interface GetModelsRequest {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetModelsRequest {
+    
+    const filterSensitiveLog: (obj: GetModelsRequest) => any;
+}
+
+export interface Model {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    description?: string;
+    
+    eventTypeName?: string;
+    
+    createdTime?: string;
+    
+    lastUpdatedTime?: string;
+    
+    arn?: string;
+}
+export declare namespace Model {
+    
+    const filterSensitiveLog: (obj: Model) => any;
+}
+export interface GetModelsResult {
+    
+    nextToken?: string;
+    
+    models?: Model[];
+}
+export declare namespace GetModelsResult {
+    
+    const filterSensitiveLog: (obj: GetModelsResult) => any;
+}
+export interface GetModelVersionRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    modelVersionNumber: string | undefined;
+}
+export declare namespace GetModelVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetModelVersionRequest) => any;
+}
+export interface GetModelVersionResult {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    modelVersionNumber?: string;
+    
+    trainingDataSource?: TrainingDataSourceEnum | string;
+    
+    trainingDataSchema?: TrainingDataSchema;
+    
+    externalEventsDetail?: ExternalEventsDetail;
+    
+    ingestedEventsDetail?: IngestedEventsDetail;
+    
+    status?: string;
+    
+    arn?: string;
+}
+export declare namespace GetModelVersionResult {
+    
+    const filterSensitiveLog: (obj: GetModelVersionResult) => any;
+}
+export interface GetOutcomesRequest {
+    
+    name?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetOutcomesRequest {
+    
+    const filterSensitiveLog: (obj: GetOutcomesRequest) => any;
+}
+
+export interface Outcome {
+    
+    name?: string;
+    
+    description?: string;
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace Outcome {
+    
+    const filterSensitiveLog: (obj: Outcome) => any;
+}
+export interface GetOutcomesResult {
+    
+    outcomes?: Outcome[];
+    
+    nextToken?: string;
+}
+export declare namespace GetOutcomesResult {
+    
+    const filterSensitiveLog: (obj: GetOutcomesResult) => any;
+}
+export interface GetRulesRequest {
+    
+    ruleId?: string;
+    
+    detectorId: string | undefined;
+    
+    ruleVersion?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetRulesRequest {
+    
+    const filterSensitiveLog: (obj: GetRulesRequest) => any;
+}
+
+export interface RuleDetail {
+    
+    ruleId?: string;
+    
+    description?: string;
+    
+    detectorId?: string;
+    
+    ruleVersion?: string;
+    
+    expression?: string;
+    
+    language?: Language | string;
+    
+    outcomes?: string[];
+    
+    lastUpdatedTime?: string;
+    
+    createdTime?: string;
+    
+    arn?: string;
+}
+export declare namespace RuleDetail {
+    
+    const filterSensitiveLog: (obj: RuleDetail) => any;
+}
+export interface GetRulesResult {
+    
+    ruleDetails?: RuleDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace GetRulesResult {
+    
+    const filterSensitiveLog: (obj: GetRulesResult) => any;
+}
+export interface GetVariablesRequest {
+    
+    name?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetVariablesRequest {
+    
+    const filterSensitiveLog: (obj: GetVariablesRequest) => any;
+}
+export interface GetVariablesResult {
+    
+    variables?: Variable[];
+    
+    nextToken?: string;
+}
+export declare namespace GetVariablesResult {
+    
+    const filterSensitiveLog: (obj: GetVariablesResult) => any;
+}
+
+export interface FilterCondition {
+    
+    value?: string;
+}
+export declare namespace FilterCondition {
+    
+    const filterSensitiveLog: (obj: FilterCondition) => any;
+}
+
+export interface PredictionTimeRange {
+    
+    startTime: string | undefined;
+    
+    endTime: string | undefined;
+}
+export declare namespace PredictionTimeRange {
+    
+    const filterSensitiveLog: (obj: PredictionTimeRange) => any;
+}
+export interface ListEventPredictionsRequest {
+    
+    eventId?: FilterCondition;
+    
+    eventType?: FilterCondition;
+    
+    detectorId?: FilterCondition;
+    
+    detectorVersionId?: FilterCondition;
+    
+    predictionTimeRange?: PredictionTimeRange;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListEventPredictionsRequest {
+    
+    const filterSensitiveLog: (obj: ListEventPredictionsRequest) => any;
+}
+
+export interface EventPredictionSummary {
+    
+    eventId?: string;
+    
+    eventTypeName?: string;
+    
+    eventTimestamp?: string;
+    
+    predictionTimestamp?: string;
+    
+    detectorId?: string;
+    
+    detectorVersionId?: string;
+}
+export declare namespace EventPredictionSummary {
+    
+    const filterSensitiveLog: (obj: EventPredictionSummary) => any;
+}
+export interface ListEventPredictionsResult {
+    
+    eventPredictionSummaries?: EventPredictionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListEventPredictionsResult {
+    
+    const filterSensitiveLog: (obj: ListEventPredictionsResult) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResult {
+    
+    tags?: Tag[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceResult {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResult) => any;
+}
+export interface PutDetectorRequest {
+    
+    detectorId: string | undefined;
+    
+    description?: string;
+    
+    eventTypeName: string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace PutDetectorRequest {
+    
+    const filterSensitiveLog: (obj: PutDetectorRequest) => any;
+}
+export interface PutDetectorResult {
+}
+export declare namespace PutDetectorResult {
+    
+    const filterSensitiveLog: (obj: PutDetectorResult) => any;
+}
+export interface PutEntityTypeRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace PutEntityTypeRequest {
+    
+    const filterSensitiveLog: (obj: PutEntityTypeRequest) => any;
+}
+export interface PutEntityTypeResult {
+}
+export declare namespace PutEntityTypeResult {
+    
+    const filterSensitiveLog: (obj: PutEntityTypeResult) => any;
+}
+export interface PutEventTypeRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    eventVariables: string[] | undefined;
+    
+    labels?: string[];
+    
+    entityTypes: string[] | undefined;
+    
+    eventIngestion?: EventIngestion | string;
+    
+    tags?: Tag[];
+}
+export declare namespace PutEventTypeRequest {
+    
+    const filterSensitiveLog: (obj: PutEventTypeRequest) => any;
+}
+export interface PutEventTypeResult {
+}
+export declare namespace PutEventTypeResult {
+    
+    const filterSensitiveLog: (obj: PutEventTypeResult) => any;
+}
+export interface PutExternalModelRequest {
+    
+    modelEndpoint: string | undefined;
+    
+    modelSource: ModelSource | string | undefined;
+    
+    invokeModelEndpointRoleArn: string | undefined;
+    
+    inputConfiguration: ModelInputConfiguration | undefined;
+    
+    outputConfiguration: ModelOutputConfiguration | undefined;
+    
+    modelEndpointStatus: ModelEndpointStatus | string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace PutExternalModelRequest {
+    
+    const filterSensitiveLog: (obj: PutExternalModelRequest) => any;
+}
+export interface PutExternalModelResult {
+}
+export declare namespace PutExternalModelResult {
+    
+    const filterSensitiveLog: (obj: PutExternalModelResult) => any;
+}
+export interface PutKMSEncryptionKeyRequest {
+    
+    kmsEncryptionKeyArn: string | undefined;
+}
+export declare namespace PutKMSEncryptionKeyRequest {
+    
+    const filterSensitiveLog: (obj: PutKMSEncryptionKeyRequest) => any;
+}
+export interface PutKMSEncryptionKeyResult {
+}
+export declare namespace PutKMSEncryptionKeyResult {
+    
+    const filterSensitiveLog: (obj: PutKMSEncryptionKeyResult) => any;
+}
+export interface PutLabelRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace PutLabelRequest {
+    
+    const filterSensitiveLog: (obj: PutLabelRequest) => any;
+}
+export interface PutLabelResult {
+}
+export declare namespace PutLabelResult {
+    
+    const filterSensitiveLog: (obj: PutLabelResult) => any;
+}
+export interface PutOutcomeRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace PutOutcomeRequest {
+    
+    const filterSensitiveLog: (obj: PutOutcomeRequest) => any;
+}
+export interface PutOutcomeResult {
+}
+export declare namespace PutOutcomeResult {
+    
+    const filterSensitiveLog: (obj: PutOutcomeResult) => any;
+}
+export interface SendEventRequest {
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    eventTimestamp: string | undefined;
+    
+    eventVariables: {
+        [key: string]: string;
+    } | undefined;
+    
+    assignedLabel?: string;
+    
+    labelTimestamp?: string;
+    
+    entities: Entity[] | undefined;
+}
+export declare namespace SendEventRequest {
+    
+    const filterSensitiveLog: (obj: SendEventRequest) => any;
+}
+export interface SendEventResult {
+}
+export declare namespace SendEventResult {
+    
+    const filterSensitiveLog: (obj: SendEventResult) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResult {
+}
+export declare namespace TagResourceResult {
+    
+    const filterSensitiveLog: (obj: TagResourceResult) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResult {
+}
+export declare namespace UntagResourceResult {
+    
+    const filterSensitiveLog: (obj: UntagResourceResult) => any;
+}
+export interface UpdateDetectorVersionRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+    
+    externalModelEndpoints: string[] | undefined;
+    
+    rules: Rule[] | undefined;
+    
+    description?: string;
+    
+    modelVersions?: ModelVersion[];
+    
+    ruleExecutionMode?: RuleExecutionMode | string;
+}
+export declare namespace UpdateDetectorVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionRequest) => any;
+}
+export interface UpdateDetectorVersionResult {
+}
+export declare namespace UpdateDetectorVersionResult {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionResult) => any;
+}
+export interface UpdateDetectorVersionMetadataRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+    
+    description: string | undefined;
+}
+export declare namespace UpdateDetectorVersionMetadataRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionMetadataRequest) => any;
+}
+export interface UpdateDetectorVersionMetadataResult {
+}
+export declare namespace UpdateDetectorVersionMetadataResult {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionMetadataResult) => any;
+}
+export interface UpdateDetectorVersionStatusRequest {
+    
+    detectorId: string | undefined;
+    
+    detectorVersionId: string | undefined;
+    
+    status: DetectorVersionStatus | string | undefined;
+}
+export declare namespace UpdateDetectorVersionStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionStatusRequest) => any;
+}
+export interface UpdateDetectorVersionStatusResult {
+}
+export declare namespace UpdateDetectorVersionStatusResult {
+    
+    const filterSensitiveLog: (obj: UpdateDetectorVersionStatusResult) => any;
+}
+export interface UpdateEventLabelRequest {
+    
+    eventId: string | undefined;
+    
+    eventTypeName: string | undefined;
+    
+    assignedLabel: string | undefined;
+    
+    labelTimestamp: string | undefined;
+}
+export declare namespace UpdateEventLabelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEventLabelRequest) => any;
+}
+export interface UpdateEventLabelResult {
+}
+export declare namespace UpdateEventLabelResult {
+    
+    const filterSensitiveLog: (obj: UpdateEventLabelResult) => any;
+}
+export interface UpdateModelRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    description?: string;
+}
+export declare namespace UpdateModelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateModelRequest) => any;
+}
+export interface UpdateModelResult {
+}
+export declare namespace UpdateModelResult {
+    
+    const filterSensitiveLog: (obj: UpdateModelResult) => any;
+}
+export interface UpdateModelVersionRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    majorVersionNumber: string | undefined;
+    
+    externalEventsDetail?: ExternalEventsDetail;
+    
+    ingestedEventsDetail?: IngestedEventsDetail;
+    
+    tags?: Tag[];
+}
+export declare namespace UpdateModelVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateModelVersionRequest) => any;
+}
+export interface UpdateModelVersionResult {
+    
+    modelId?: string;
+    
+    modelType?: ModelTypeEnum | string;
+    
+    modelVersionNumber?: string;
+    
+    status?: string;
+}
+export declare namespace UpdateModelVersionResult {
+    
+    const filterSensitiveLog: (obj: UpdateModelVersionResult) => any;
+}
+export declare enum ModelVersionStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    TRAINING_CANCELLED = "TRAINING_CANCELLED"
+}
+export interface UpdateModelVersionStatusRequest {
+    
+    modelId: string | undefined;
+    
+    modelType: ModelTypeEnum | string | undefined;
+    
+    modelVersionNumber: string | undefined;
+    
+    status: ModelVersionStatus | string | undefined;
+}
+export declare namespace UpdateModelVersionStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateModelVersionStatusRequest) => any;
+}
+export interface UpdateModelVersionStatusResult {
+}
+export declare namespace UpdateModelVersionStatusResult {
+    
+    const filterSensitiveLog: (obj: UpdateModelVersionStatusResult) => any;
+}
+export interface UpdateRuleMetadataRequest {
+    
+    rule: Rule | undefined;
+    
+    description: string | undefined;
+}
+export declare namespace UpdateRuleMetadataRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRuleMetadataRequest) => any;
+}
+export interface UpdateRuleMetadataResult {
+}
+export declare namespace UpdateRuleMetadataResult {
+    
+    const filterSensitiveLog: (obj: UpdateRuleMetadataResult) => any;
+}
+export interface UpdateRuleVersionRequest {
+    
+    rule: Rule | undefined;
+    
+    description?: string;
+    
+    expression: string | undefined;
+    
+    language: Language | string | undefined;
+    
+    outcomes: string[] | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace UpdateRuleVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRuleVersionRequest) => any;
+}
+export interface UpdateRuleVersionResult {
+    
+    rule?: Rule;
+}
+export declare namespace UpdateRuleVersionResult {
+    
+    const filterSensitiveLog: (obj: UpdateRuleVersionResult) => any;
+}
+export interface UpdateVariableRequest {
+    
+    name: string | undefined;
+    
+    defaultValue?: string;
+    
+    description?: string;
+    
+    variableType?: string;
+}
+export declare namespace UpdateVariableRequest {
+    
+    const filterSensitiveLog: (obj: UpdateVariableRequest) => any;
+}
+export interface UpdateVariableResult {
+}
+export declare namespace UpdateVariableResult {
+    
+    const filterSensitiveLog: (obj: UpdateVariableResult) => any;
+}