@aws-sdk/client-sfn 3.34.0 → 3.37.0

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

@@ -0,0 +1,1331 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ActivityDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "ActivityDoesNotExist";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ActivityDoesNotExist {
+    
+    const filterSensitiveLog: (obj: ActivityDoesNotExist) => any;
+}
+
+export interface ActivityFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ActivityFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivityFailedEventDetails) => any;
+}
+
+export interface ActivityLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "ActivityLimitExceeded";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ActivityLimitExceeded {
+    
+    const filterSensitiveLog: (obj: ActivityLimitExceeded) => any;
+}
+
+export interface ActivityListItem {
+    
+    activityArn: string | undefined;
+    
+    name: string | undefined;
+    
+    creationDate: Date | undefined;
+}
+export declare namespace ActivityListItem {
+    
+    const filterSensitiveLog: (obj: ActivityListItem) => any;
+}
+
+export interface HistoryEventExecutionDataDetails {
+    
+    truncated?: boolean;
+}
+export declare namespace HistoryEventExecutionDataDetails {
+    
+    const filterSensitiveLog: (obj: HistoryEventExecutionDataDetails) => any;
+}
+
+export interface ActivityScheduledEventDetails {
+    
+    resource: string | undefined;
+    
+    input?: string;
+    
+    inputDetails?: HistoryEventExecutionDataDetails;
+    
+    timeoutInSeconds?: number;
+    
+    heartbeatInSeconds?: number;
+}
+export declare namespace ActivityScheduledEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivityScheduledEventDetails) => any;
+}
+
+export interface ActivityScheduleFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ActivityScheduleFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivityScheduleFailedEventDetails) => any;
+}
+
+export interface ActivityStartedEventDetails {
+    
+    workerName?: string;
+}
+export declare namespace ActivityStartedEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivityStartedEventDetails) => any;
+}
+
+export interface ActivitySucceededEventDetails {
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace ActivitySucceededEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivitySucceededEventDetails) => any;
+}
+
+export interface ActivityTimedOutEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ActivityTimedOutEventDetails {
+    
+    const filterSensitiveLog: (obj: ActivityTimedOutEventDetails) => any;
+}
+
+export interface ActivityWorkerLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "ActivityWorkerLimitExceeded";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ActivityWorkerLimitExceeded {
+    
+    const filterSensitiveLog: (obj: ActivityWorkerLimitExceeded) => any;
+}
+
+export interface Tag {
+    
+    key?: string;
+    
+    value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateActivityInput {
+    
+    name: string | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateActivityInput {
+    
+    const filterSensitiveLog: (obj: CreateActivityInput) => any;
+}
+export interface CreateActivityOutput {
+    
+    activityArn: string | undefined;
+    
+    creationDate: Date | undefined;
+}
+export declare namespace CreateActivityOutput {
+    
+    const filterSensitiveLog: (obj: CreateActivityOutput) => any;
+}
+
+export interface InvalidName extends __SmithyException, $MetadataBearer {
+    name: "InvalidName";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidName {
+    
+    const filterSensitiveLog: (obj: InvalidName) => any;
+}
+
+export interface TooManyTags extends __SmithyException, $MetadataBearer {
+    name: "TooManyTags";
+    $fault: "client";
+    message?: string;
+    resourceName?: string;
+}
+export declare namespace TooManyTags {
+    
+    const filterSensitiveLog: (obj: TooManyTags) => any;
+}
+
+export interface CloudWatchLogsLogGroup {
+    
+    logGroupArn?: string;
+}
+export declare namespace CloudWatchLogsLogGroup {
+    
+    const filterSensitiveLog: (obj: CloudWatchLogsLogGroup) => any;
+}
+
+export interface LogDestination {
+    
+    cloudWatchLogsLogGroup?: CloudWatchLogsLogGroup;
+}
+export declare namespace LogDestination {
+    
+    const filterSensitiveLog: (obj: LogDestination) => any;
+}
+export declare type LogLevel = "ALL" | "ERROR" | "FATAL" | "OFF";
+
+export interface LoggingConfiguration {
+    
+    level?: LogLevel | string;
+    
+    includeExecutionData?: boolean;
+    
+    destinations?: LogDestination[];
+}
+export declare namespace LoggingConfiguration {
+    
+    const filterSensitiveLog: (obj: LoggingConfiguration) => any;
+}
+
+export interface TracingConfiguration {
+    
+    enabled?: boolean;
+}
+export declare namespace TracingConfiguration {
+    
+    const filterSensitiveLog: (obj: TracingConfiguration) => any;
+}
+export declare type StateMachineType = "EXPRESS" | "STANDARD";
+export interface CreateStateMachineInput {
+    
+    name: string | undefined;
+    
+    definition: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    type?: StateMachineType | string;
+    
+    loggingConfiguration?: LoggingConfiguration;
+    
+    tags?: Tag[];
+    
+    tracingConfiguration?: TracingConfiguration;
+}
+export declare namespace CreateStateMachineInput {
+    
+    const filterSensitiveLog: (obj: CreateStateMachineInput) => any;
+}
+export interface CreateStateMachineOutput {
+    
+    stateMachineArn: string | undefined;
+    
+    creationDate: Date | undefined;
+}
+export declare namespace CreateStateMachineOutput {
+    
+    const filterSensitiveLog: (obj: CreateStateMachineOutput) => any;
+}
+
+export interface InvalidArn extends __SmithyException, $MetadataBearer {
+    name: "InvalidArn";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidArn {
+    
+    const filterSensitiveLog: (obj: InvalidArn) => any;
+}
+
+export interface InvalidDefinition extends __SmithyException, $MetadataBearer {
+    name: "InvalidDefinition";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDefinition {
+    
+    const filterSensitiveLog: (obj: InvalidDefinition) => any;
+}
+
+export interface InvalidLoggingConfiguration extends __SmithyException, $MetadataBearer {
+    name: "InvalidLoggingConfiguration";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidLoggingConfiguration {
+    
+    const filterSensitiveLog: (obj: InvalidLoggingConfiguration) => any;
+}
+
+export interface InvalidTracingConfiguration extends __SmithyException, $MetadataBearer {
+    name: "InvalidTracingConfiguration";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTracingConfiguration {
+    
+    const filterSensitiveLog: (obj: InvalidTracingConfiguration) => any;
+}
+
+export interface StateMachineAlreadyExists extends __SmithyException, $MetadataBearer {
+    name: "StateMachineAlreadyExists";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StateMachineAlreadyExists {
+    
+    const filterSensitiveLog: (obj: StateMachineAlreadyExists) => any;
+}
+
+export interface StateMachineDeleting extends __SmithyException, $MetadataBearer {
+    name: "StateMachineDeleting";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StateMachineDeleting {
+    
+    const filterSensitiveLog: (obj: StateMachineDeleting) => any;
+}
+
+export interface StateMachineLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "StateMachineLimitExceeded";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StateMachineLimitExceeded {
+    
+    const filterSensitiveLog: (obj: StateMachineLimitExceeded) => any;
+}
+
+export interface StateMachineTypeNotSupported extends __SmithyException, $MetadataBearer {
+    name: "StateMachineTypeNotSupported";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StateMachineTypeNotSupported {
+    
+    const filterSensitiveLog: (obj: StateMachineTypeNotSupported) => any;
+}
+export interface DeleteActivityInput {
+    
+    activityArn: string | undefined;
+}
+export declare namespace DeleteActivityInput {
+    
+    const filterSensitiveLog: (obj: DeleteActivityInput) => any;
+}
+export interface DeleteActivityOutput {
+}
+export declare namespace DeleteActivityOutput {
+    
+    const filterSensitiveLog: (obj: DeleteActivityOutput) => any;
+}
+export interface DeleteStateMachineInput {
+    
+    stateMachineArn: string | undefined;
+}
+export declare namespace DeleteStateMachineInput {
+    
+    const filterSensitiveLog: (obj: DeleteStateMachineInput) => any;
+}
+export interface DeleteStateMachineOutput {
+}
+export declare namespace DeleteStateMachineOutput {
+    
+    const filterSensitiveLog: (obj: DeleteStateMachineOutput) => any;
+}
+export interface DescribeActivityInput {
+    
+    activityArn: string | undefined;
+}
+export declare namespace DescribeActivityInput {
+    
+    const filterSensitiveLog: (obj: DescribeActivityInput) => any;
+}
+export interface DescribeActivityOutput {
+    
+    activityArn: string | undefined;
+    
+    name: string | undefined;
+    
+    creationDate: Date | undefined;
+}
+export declare namespace DescribeActivityOutput {
+    
+    const filterSensitiveLog: (obj: DescribeActivityOutput) => any;
+}
+export interface DescribeExecutionInput {
+    
+    executionArn: string | undefined;
+}
+export declare namespace DescribeExecutionInput {
+    
+    const filterSensitiveLog: (obj: DescribeExecutionInput) => any;
+}
+
+export interface CloudWatchEventsExecutionDataDetails {
+    
+    included?: boolean;
+}
+export declare namespace CloudWatchEventsExecutionDataDetails {
+    
+    const filterSensitiveLog: (obj: CloudWatchEventsExecutionDataDetails) => any;
+}
+export declare type ExecutionStatus = "ABORTED" | "FAILED" | "RUNNING" | "SUCCEEDED" | "TIMED_OUT";
+export interface DescribeExecutionOutput {
+    
+    executionArn: string | undefined;
+    
+    stateMachineArn: string | undefined;
+    
+    name?: string;
+    
+    status: ExecutionStatus | string | undefined;
+    
+    startDate: Date | undefined;
+    
+    stopDate?: Date;
+    
+    input?: string;
+    
+    inputDetails?: CloudWatchEventsExecutionDataDetails;
+    
+    output?: string;
+    
+    outputDetails?: CloudWatchEventsExecutionDataDetails;
+    
+    traceHeader?: string;
+}
+export declare namespace DescribeExecutionOutput {
+    
+    const filterSensitiveLog: (obj: DescribeExecutionOutput) => any;
+}
+
+export interface ExecutionDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "ExecutionDoesNotExist";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ExecutionDoesNotExist {
+    
+    const filterSensitiveLog: (obj: ExecutionDoesNotExist) => any;
+}
+export interface DescribeStateMachineInput {
+    
+    stateMachineArn: string | undefined;
+}
+export declare namespace DescribeStateMachineInput {
+    
+    const filterSensitiveLog: (obj: DescribeStateMachineInput) => any;
+}
+export declare type StateMachineStatus = "ACTIVE" | "DELETING";
+export interface DescribeStateMachineOutput {
+    
+    stateMachineArn: string | undefined;
+    
+    name: string | undefined;
+    
+    status?: StateMachineStatus | string;
+    
+    definition: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    type: StateMachineType | string | undefined;
+    
+    creationDate: Date | undefined;
+    
+    loggingConfiguration?: LoggingConfiguration;
+    
+    tracingConfiguration?: TracingConfiguration;
+}
+export declare namespace DescribeStateMachineOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStateMachineOutput) => any;
+}
+
+export interface StateMachineDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "StateMachineDoesNotExist";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StateMachineDoesNotExist {
+    
+    const filterSensitiveLog: (obj: StateMachineDoesNotExist) => any;
+}
+export interface DescribeStateMachineForExecutionInput {
+    
+    executionArn: string | undefined;
+}
+export declare namespace DescribeStateMachineForExecutionInput {
+    
+    const filterSensitiveLog: (obj: DescribeStateMachineForExecutionInput) => any;
+}
+export interface DescribeStateMachineForExecutionOutput {
+    
+    stateMachineArn: string | undefined;
+    
+    name: string | undefined;
+    
+    definition: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    updateDate: Date | undefined;
+    
+    loggingConfiguration?: LoggingConfiguration;
+    
+    tracingConfiguration?: TracingConfiguration;
+}
+export declare namespace DescribeStateMachineForExecutionOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStateMachineForExecutionOutput) => any;
+}
+export interface GetActivityTaskInput {
+    
+    activityArn: string | undefined;
+    
+    workerName?: string;
+}
+export declare namespace GetActivityTaskInput {
+    
+    const filterSensitiveLog: (obj: GetActivityTaskInput) => any;
+}
+export interface GetActivityTaskOutput {
+    
+    taskToken?: string;
+    
+    input?: string;
+}
+export declare namespace GetActivityTaskOutput {
+    
+    const filterSensitiveLog: (obj: GetActivityTaskOutput) => any;
+}
+export interface GetExecutionHistoryInput {
+    
+    executionArn: string | undefined;
+    
+    maxResults?: number;
+    
+    reverseOrder?: boolean;
+    
+    nextToken?: string;
+    
+    includeExecutionData?: boolean;
+}
+export declare namespace GetExecutionHistoryInput {
+    
+    const filterSensitiveLog: (obj: GetExecutionHistoryInput) => any;
+}
+
+export interface ExecutionAbortedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ExecutionAbortedEventDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionAbortedEventDetails) => any;
+}
+
+export interface ExecutionFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ExecutionFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionFailedEventDetails) => any;
+}
+
+export interface ExecutionStartedEventDetails {
+    
+    input?: string;
+    
+    inputDetails?: HistoryEventExecutionDataDetails;
+    
+    roleArn?: string;
+}
+export declare namespace ExecutionStartedEventDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionStartedEventDetails) => any;
+}
+
+export interface ExecutionSucceededEventDetails {
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace ExecutionSucceededEventDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionSucceededEventDetails) => any;
+}
+
+export interface ExecutionTimedOutEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace ExecutionTimedOutEventDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionTimedOutEventDetails) => any;
+}
+
+export interface LambdaFunctionFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace LambdaFunctionFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionFailedEventDetails) => any;
+}
+
+export interface LambdaFunctionScheduledEventDetails {
+    
+    resource: string | undefined;
+    
+    input?: string;
+    
+    inputDetails?: HistoryEventExecutionDataDetails;
+    
+    timeoutInSeconds?: number;
+}
+export declare namespace LambdaFunctionScheduledEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionScheduledEventDetails) => any;
+}
+
+export interface LambdaFunctionScheduleFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace LambdaFunctionScheduleFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionScheduleFailedEventDetails) => any;
+}
+
+export interface LambdaFunctionStartFailedEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace LambdaFunctionStartFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionStartFailedEventDetails) => any;
+}
+
+export interface LambdaFunctionSucceededEventDetails {
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace LambdaFunctionSucceededEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionSucceededEventDetails) => any;
+}
+
+export interface LambdaFunctionTimedOutEventDetails {
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace LambdaFunctionTimedOutEventDetails {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionTimedOutEventDetails) => any;
+}
+
+export interface MapIterationEventDetails {
+    
+    name?: string;
+    
+    index?: number;
+}
+export declare namespace MapIterationEventDetails {
+    
+    const filterSensitiveLog: (obj: MapIterationEventDetails) => any;
+}
+
+export interface MapStateStartedEventDetails {
+    
+    length?: number;
+}
+export declare namespace MapStateStartedEventDetails {
+    
+    const filterSensitiveLog: (obj: MapStateStartedEventDetails) => any;
+}
+
+export interface StateEnteredEventDetails {
+    
+    name: string | undefined;
+    
+    input?: string;
+    
+    inputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace StateEnteredEventDetails {
+    
+    const filterSensitiveLog: (obj: StateEnteredEventDetails) => any;
+}
+
+export interface StateExitedEventDetails {
+    
+    name: string | undefined;
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace StateExitedEventDetails {
+    
+    const filterSensitiveLog: (obj: StateExitedEventDetails) => any;
+}
+
+export interface TaskFailedEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace TaskFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskFailedEventDetails) => any;
+}
+
+export interface TaskScheduledEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    region: string | undefined;
+    
+    parameters: string | undefined;
+    
+    timeoutInSeconds?: number;
+    
+    heartbeatInSeconds?: number;
+}
+export declare namespace TaskScheduledEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskScheduledEventDetails) => any;
+}
+
+export interface TaskStartedEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+}
+export declare namespace TaskStartedEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskStartedEventDetails) => any;
+}
+
+export interface TaskStartFailedEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace TaskStartFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskStartFailedEventDetails) => any;
+}
+
+export interface TaskSubmitFailedEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace TaskSubmitFailedEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskSubmitFailedEventDetails) => any;
+}
+
+export interface TaskSubmittedEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace TaskSubmittedEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskSubmittedEventDetails) => any;
+}
+
+export interface TaskSucceededEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    output?: string;
+    
+    outputDetails?: HistoryEventExecutionDataDetails;
+}
+export declare namespace TaskSucceededEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskSucceededEventDetails) => any;
+}
+
+export interface TaskTimedOutEventDetails {
+    
+    resourceType: string | undefined;
+    
+    resource: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace TaskTimedOutEventDetails {
+    
+    const filterSensitiveLog: (obj: TaskTimedOutEventDetails) => any;
+}
+export declare type HistoryEventType = "ActivityFailed" | "ActivityScheduleFailed" | "ActivityScheduled" | "ActivityStarted" | "ActivitySucceeded" | "ActivityTimedOut" | "ChoiceStateEntered" | "ChoiceStateExited" | "ExecutionAborted" | "ExecutionFailed" | "ExecutionStarted" | "ExecutionSucceeded" | "ExecutionTimedOut" | "FailStateEntered" | "LambdaFunctionFailed" | "LambdaFunctionScheduleFailed" | "LambdaFunctionScheduled" | "LambdaFunctionStartFailed" | "LambdaFunctionStarted" | "LambdaFunctionSucceeded" | "LambdaFunctionTimedOut" | "MapIterationAborted" | "MapIterationFailed" | "MapIterationStarted" | "MapIterationSucceeded" | "MapStateAborted" | "MapStateEntered" | "MapStateExited" | "MapStateFailed" | "MapStateStarted" | "MapStateSucceeded" | "ParallelStateAborted" | "ParallelStateEntered" | "ParallelStateExited" | "ParallelStateFailed" | "ParallelStateStarted" | "ParallelStateSucceeded" | "PassStateEntered" | "PassStateExited" | "SucceedStateEntered" | "SucceedStateExited" | "TaskFailed" | "TaskScheduled" | "TaskStartFailed" | "TaskStarted" | "TaskStateAborted" | "TaskStateEntered" | "TaskStateExited" | "TaskSubmitFailed" | "TaskSubmitted" | "TaskSucceeded" | "TaskTimedOut" | "WaitStateAborted" | "WaitStateEntered" | "WaitStateExited";
+
+export interface HistoryEvent {
+    
+    timestamp: Date | undefined;
+    
+    type: HistoryEventType | string | undefined;
+    
+    id: number | undefined;
+    
+    previousEventId?: number;
+    
+    activityFailedEventDetails?: ActivityFailedEventDetails;
+    
+    activityScheduleFailedEventDetails?: ActivityScheduleFailedEventDetails;
+    
+    activityScheduledEventDetails?: ActivityScheduledEventDetails;
+    
+    activityStartedEventDetails?: ActivityStartedEventDetails;
+    
+    activitySucceededEventDetails?: ActivitySucceededEventDetails;
+    
+    activityTimedOutEventDetails?: ActivityTimedOutEventDetails;
+    
+    taskFailedEventDetails?: TaskFailedEventDetails;
+    
+    taskScheduledEventDetails?: TaskScheduledEventDetails;
+    
+    taskStartFailedEventDetails?: TaskStartFailedEventDetails;
+    
+    taskStartedEventDetails?: TaskStartedEventDetails;
+    
+    taskSubmitFailedEventDetails?: TaskSubmitFailedEventDetails;
+    
+    taskSubmittedEventDetails?: TaskSubmittedEventDetails;
+    
+    taskSucceededEventDetails?: TaskSucceededEventDetails;
+    
+    taskTimedOutEventDetails?: TaskTimedOutEventDetails;
+    
+    executionFailedEventDetails?: ExecutionFailedEventDetails;
+    
+    executionStartedEventDetails?: ExecutionStartedEventDetails;
+    
+    executionSucceededEventDetails?: ExecutionSucceededEventDetails;
+    
+    executionAbortedEventDetails?: ExecutionAbortedEventDetails;
+    
+    executionTimedOutEventDetails?: ExecutionTimedOutEventDetails;
+    
+    mapStateStartedEventDetails?: MapStateStartedEventDetails;
+    
+    mapIterationStartedEventDetails?: MapIterationEventDetails;
+    
+    mapIterationSucceededEventDetails?: MapIterationEventDetails;
+    
+    mapIterationFailedEventDetails?: MapIterationEventDetails;
+    
+    mapIterationAbortedEventDetails?: MapIterationEventDetails;
+    
+    lambdaFunctionFailedEventDetails?: LambdaFunctionFailedEventDetails;
+    
+    lambdaFunctionScheduleFailedEventDetails?: LambdaFunctionScheduleFailedEventDetails;
+    
+    lambdaFunctionScheduledEventDetails?: LambdaFunctionScheduledEventDetails;
+    
+    lambdaFunctionStartFailedEventDetails?: LambdaFunctionStartFailedEventDetails;
+    
+    lambdaFunctionSucceededEventDetails?: LambdaFunctionSucceededEventDetails;
+    
+    lambdaFunctionTimedOutEventDetails?: LambdaFunctionTimedOutEventDetails;
+    
+    stateEnteredEventDetails?: StateEnteredEventDetails;
+    
+    stateExitedEventDetails?: StateExitedEventDetails;
+}
+export declare namespace HistoryEvent {
+    
+    const filterSensitiveLog: (obj: HistoryEvent) => any;
+}
+export interface GetExecutionHistoryOutput {
+    
+    events: HistoryEvent[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace GetExecutionHistoryOutput {
+    
+    const filterSensitiveLog: (obj: GetExecutionHistoryOutput) => any;
+}
+
+export interface InvalidToken extends __SmithyException, $MetadataBearer {
+    name: "InvalidToken";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidToken {
+    
+    const filterSensitiveLog: (obj: InvalidToken) => any;
+}
+export interface ListActivitiesInput {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListActivitiesInput {
+    
+    const filterSensitiveLog: (obj: ListActivitiesInput) => any;
+}
+export interface ListActivitiesOutput {
+    
+    activities: ActivityListItem[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListActivitiesOutput {
+    
+    const filterSensitiveLog: (obj: ListActivitiesOutput) => any;
+}
+export interface ListExecutionsInput {
+    
+    stateMachineArn: string | undefined;
+    
+    statusFilter?: ExecutionStatus | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListExecutionsInput {
+    
+    const filterSensitiveLog: (obj: ListExecutionsInput) => any;
+}
+
+export interface ExecutionListItem {
+    
+    executionArn: string | undefined;
+    
+    stateMachineArn: string | undefined;
+    
+    name: string | undefined;
+    
+    status: ExecutionStatus | string | undefined;
+    
+    startDate: Date | undefined;
+    
+    stopDate?: Date;
+}
+export declare namespace ExecutionListItem {
+    
+    const filterSensitiveLog: (obj: ExecutionListItem) => any;
+}
+export interface ListExecutionsOutput {
+    
+    executions: ExecutionListItem[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListExecutionsOutput {
+    
+    const filterSensitiveLog: (obj: ListExecutionsOutput) => any;
+}
+export interface ListStateMachinesInput {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListStateMachinesInput {
+    
+    const filterSensitiveLog: (obj: ListStateMachinesInput) => any;
+}
+
+export interface StateMachineListItem {
+    
+    stateMachineArn: string | undefined;
+    
+    name: string | undefined;
+    
+    type: StateMachineType | string | undefined;
+    
+    creationDate: Date | undefined;
+}
+export declare namespace StateMachineListItem {
+    
+    const filterSensitiveLog: (obj: StateMachineListItem) => any;
+}
+export interface ListStateMachinesOutput {
+    stateMachines: StateMachineListItem[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListStateMachinesOutput {
+    
+    const filterSensitiveLog: (obj: ListStateMachinesOutput) => any;
+}
+export interface ListTagsForResourceInput {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+export interface ListTagsForResourceOutput {
+    
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+
+export interface ResourceNotFound extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFound";
+    $fault: "client";
+    message?: string;
+    resourceName?: string;
+}
+export declare namespace ResourceNotFound {
+    
+    const filterSensitiveLog: (obj: ResourceNotFound) => any;
+}
+export interface SendTaskFailureInput {
+    
+    taskToken: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace SendTaskFailureInput {
+    
+    const filterSensitiveLog: (obj: SendTaskFailureInput) => any;
+}
+export interface SendTaskFailureOutput {
+}
+export declare namespace SendTaskFailureOutput {
+    
+    const filterSensitiveLog: (obj: SendTaskFailureOutput) => any;
+}
+export interface TaskDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "TaskDoesNotExist";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TaskDoesNotExist {
+    
+    const filterSensitiveLog: (obj: TaskDoesNotExist) => any;
+}
+export interface TaskTimedOut extends __SmithyException, $MetadataBearer {
+    name: "TaskTimedOut";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TaskTimedOut {
+    
+    const filterSensitiveLog: (obj: TaskTimedOut) => any;
+}
+export interface SendTaskHeartbeatInput {
+    
+    taskToken: string | undefined;
+}
+export declare namespace SendTaskHeartbeatInput {
+    
+    const filterSensitiveLog: (obj: SendTaskHeartbeatInput) => any;
+}
+export interface SendTaskHeartbeatOutput {
+}
+export declare namespace SendTaskHeartbeatOutput {
+    
+    const filterSensitiveLog: (obj: SendTaskHeartbeatOutput) => any;
+}
+
+export interface InvalidOutput extends __SmithyException, $MetadataBearer {
+    name: "InvalidOutput";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidOutput {
+    
+    const filterSensitiveLog: (obj: InvalidOutput) => any;
+}
+export interface SendTaskSuccessInput {
+    
+    taskToken: string | undefined;
+    
+    output: string | undefined;
+}
+export declare namespace SendTaskSuccessInput {
+    
+    const filterSensitiveLog: (obj: SendTaskSuccessInput) => any;
+}
+export interface SendTaskSuccessOutput {
+}
+export declare namespace SendTaskSuccessOutput {
+    
+    const filterSensitiveLog: (obj: SendTaskSuccessOutput) => any;
+}
+
+export interface ExecutionAlreadyExists extends __SmithyException, $MetadataBearer {
+    name: "ExecutionAlreadyExists";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ExecutionAlreadyExists {
+    
+    const filterSensitiveLog: (obj: ExecutionAlreadyExists) => any;
+}
+
+export interface ExecutionLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "ExecutionLimitExceeded";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ExecutionLimitExceeded {
+    
+    const filterSensitiveLog: (obj: ExecutionLimitExceeded) => any;
+}
+
+export interface InvalidExecutionInput extends __SmithyException, $MetadataBearer {
+    name: "InvalidExecutionInput";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidExecutionInput {
+    
+    const filterSensitiveLog: (obj: InvalidExecutionInput) => any;
+}
+export interface StartExecutionInput {
+    
+    stateMachineArn: string | undefined;
+    
+    name?: string;
+    
+    input?: string;
+    
+    traceHeader?: string;
+}
+export declare namespace StartExecutionInput {
+    
+    const filterSensitiveLog: (obj: StartExecutionInput) => any;
+}
+export interface StartExecutionOutput {
+    
+    executionArn: string | undefined;
+    
+    startDate: Date | undefined;
+}
+export declare namespace StartExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StartExecutionOutput) => any;
+}
+export interface StartSyncExecutionInput {
+    
+    stateMachineArn: string | undefined;
+    
+    name?: string;
+    
+    input?: string;
+    
+    traceHeader?: string;
+}
+export declare namespace StartSyncExecutionInput {
+    
+    const filterSensitiveLog: (obj: StartSyncExecutionInput) => any;
+}
+
+export interface BillingDetails {
+    
+    billedMemoryUsedInMB?: number;
+    
+    billedDurationInMilliseconds?: number;
+}
+export declare namespace BillingDetails {
+    
+    const filterSensitiveLog: (obj: BillingDetails) => any;
+}
+export declare type SyncExecutionStatus = "FAILED" | "SUCCEEDED" | "TIMED_OUT";
+export interface StartSyncExecutionOutput {
+    
+    executionArn: string | undefined;
+    
+    stateMachineArn?: string;
+    
+    name?: string;
+    
+    startDate: Date | undefined;
+    
+    stopDate: Date | undefined;
+    
+    status: SyncExecutionStatus | string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+    
+    input?: string;
+    
+    inputDetails?: CloudWatchEventsExecutionDataDetails;
+    
+    output?: string;
+    
+    outputDetails?: CloudWatchEventsExecutionDataDetails;
+    
+    traceHeader?: string;
+    
+    billingDetails?: BillingDetails;
+}
+export declare namespace StartSyncExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StartSyncExecutionOutput) => any;
+}
+export interface StopExecutionInput {
+    
+    executionArn: string | undefined;
+    
+    error?: string;
+    
+    cause?: string;
+}
+export declare namespace StopExecutionInput {
+    
+    const filterSensitiveLog: (obj: StopExecutionInput) => any;
+}
+export interface StopExecutionOutput {
+    
+    stopDate: Date | undefined;
+}
+export declare namespace StopExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StopExecutionOutput) => any;
+}
+export interface TagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+export interface UntagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}
+
+export interface MissingRequiredParameter extends __SmithyException, $MetadataBearer {
+    name: "MissingRequiredParameter";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace MissingRequiredParameter {
+    
+    const filterSensitiveLog: (obj: MissingRequiredParameter) => any;
+}
+export interface UpdateStateMachineInput {
+    
+    stateMachineArn: string | undefined;
+    
+    definition?: string;
+    
+    roleArn?: string;
+    
+    loggingConfiguration?: LoggingConfiguration;
+    
+    tracingConfiguration?: TracingConfiguration;
+}
+export declare namespace UpdateStateMachineInput {
+    
+    const filterSensitiveLog: (obj: UpdateStateMachineInput) => any;
+}
+export interface UpdateStateMachineOutput {
+    
+    updateDate: Date | undefined;
+}
+export declare namespace UpdateStateMachineOutput {
+    
+    const filterSensitiveLog: (obj: UpdateStateMachineOutput) => any;
+}