@aws-sdk/client-mwaa-serverless 3.933.0

package/dist-cjs/index.js

@@ -0,0 +1,1324 @@
+'use strict';
+
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "airflow-serverless",
+    });
+};
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+};
+
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
+
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
+
+class MWAAServerlessClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultMWAAServerlessHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+
+let MWAAServerlessServiceException$1 = class MWAAServerlessServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, MWAAServerlessServiceException.prototype);
+    }
+};
+
+let AccessDeniedException$1 = class AccessDeniedException extends MWAAServerlessServiceException$1 {
+    name = "AccessDeniedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+};
+let InternalServerException$1 = class InternalServerException extends MWAAServerlessServiceException$1 {
+    name = "InternalServerException";
+    $fault = "server";
+    $retryable = {};
+    Message;
+    RetryAfterSeconds;
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+        this.RetryAfterSeconds = opts.RetryAfterSeconds;
+    }
+};
+let OperationTimeoutException$1 = class OperationTimeoutException extends MWAAServerlessServiceException$1 {
+    name = "OperationTimeoutException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "OperationTimeoutException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OperationTimeoutException.prototype);
+        this.Message = opts.Message;
+    }
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends MWAAServerlessServiceException$1 {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    Message;
+    ResourceId;
+    ResourceType;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+        this.ResourceId = opts.ResourceId;
+        this.ResourceType = opts.ResourceType;
+    }
+};
+let ThrottlingException$1 = class ThrottlingException extends MWAAServerlessServiceException$1 {
+    name = "ThrottlingException";
+    $fault = "client";
+    $retryable = {
+        throttling: true,
+    };
+    Message;
+    ServiceCode;
+    QuotaCode;
+    RetryAfterSeconds;
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+        this.ServiceCode = opts.ServiceCode;
+        this.QuotaCode = opts.QuotaCode;
+        this.RetryAfterSeconds = opts.RetryAfterSeconds;
+    }
+};
+const ValidationExceptionReason = {
+    CANNOT_PARSE: "cannotParse",
+    FIELD_VALIDATION_FAILED: "fieldValidationFailed",
+    OTHER: "other",
+    UNKNOWN_OPERATION: "unknownOperation",
+};
+let ValidationException$1 = class ValidationException extends MWAAServerlessServiceException$1 {
+    name = "ValidationException";
+    $fault = "client";
+    Message;
+    Reason;
+    FieldList;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+        this.Reason = opts.Reason;
+        this.FieldList = opts.FieldList;
+    }
+};
+const TaskInstanceStatus = {
+    CANCELLED: "CANCELLED",
+    DEFERRED: "DEFERRED",
+    FAILED: "FAILED",
+    NONE: "NONE",
+    QUEUED: "QUEUED",
+    REMOVED: "REMOVED",
+    RESTARTING: "RESTARTING",
+    RUNNING: "RUNNING",
+    SCHEDULED: "SCHEDULED",
+    SUCCESS: "SUCCESS",
+    TIMEOUT: "TIMEOUT",
+    UPSTREAM_FAILED: "UPSTREAM_FAILED",
+    UP_FOR_RESCHEDULE: "UP_FOR_RESCHEDULE",
+    UP_FOR_RETRY: "UP_FOR_RETRY",
+};
+let ConflictException$1 = class ConflictException extends MWAAServerlessServiceException$1 {
+    name = "ConflictException";
+    $fault = "client";
+    Message;
+    ResourceId;
+    ResourceType;
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+        this.ResourceId = opts.ResourceId;
+        this.ResourceType = opts.ResourceType;
+    }
+};
+const EncryptionType = {
+    AWS_MANAGED_KEY: "AWS_MANAGED_KEY",
+    CUSTOMER_MANAGED_KEY: "CUSTOMER_MANAGED_KEY",
+};
+exports.EngineVersion = void 0;
+(function (EngineVersion) {
+    EngineVersion[EngineVersion["ONE"] = 1] = "ONE";
+})(exports.EngineVersion || (exports.EngineVersion = {}));
+const WorkflowStatus = {
+    DELETING: "DELETING",
+    READY: "READY",
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends MWAAServerlessServiceException$1 {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    Message;
+    ResourceId;
+    ResourceType;
+    ServiceCode;
+    QuotaCode;
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+        this.ResourceId = opts.ResourceId;
+        this.ResourceType = opts.ResourceType;
+        this.ServiceCode = opts.ServiceCode;
+        this.QuotaCode = opts.QuotaCode;
+    }
+};
+const WorkflowRunStatus = {
+    FAILED: "FAILED",
+    QUEUED: "QUEUED",
+    RUNNING: "RUNNING",
+    STARTING: "STARTING",
+    STOPPED: "STOPPED",
+    STOPPING: "STOPPING",
+    SUCCESS: "SUCCESS",
+    TIMEOUT: "TIMEOUT",
+};
+const RunType = {
+    ON_DEMAND: "ON_DEMAND",
+    SCHEDULED: "SCHEDULED",
+};
+
+const _ADE = "AccessDeniedException";
+const _AN = "AttemptNumber";
+const _B = "Bucket";
+const _CA = "CreatedAt";
+const _CE = "ConflictException";
+const _CEr = "CronExpression";
+const _CO = "CreatedOn";
+const _COo = "CompletedOn";
+const _CT = "ClientToken";
+const _CW = "CreateWorkflow";
+const _CWR = "CreateWorkflowRequest";
+const _CWRr = "CreateWorkflowResponse";
+const _D = "Description";
+const _DIS = "DurationInSeconds";
+const _DSL = "DefinitionS3Location";
+const _DW = "DeleteWorkflow";
+const _DWR = "DeleteWorkflowRequest";
+const _DWRe = "DeleteWorkflowResponse";
+const _Du = "Duration";
+const _EA = "EndedAt";
+const _EC = "EncryptionConfiguration";
+const _EM = "ErrorMessage";
+const _EV = "EngineVersion";
+const _FL = "FieldList";
+const _GTI = "GetTaskInstance";
+const _GTIR = "GetTaskInstanceRequest";
+const _GTIRe = "GetTaskInstanceResponse";
+const _GW = "GetWorkflow";
+const _GWR = "GetWorkflowRequest";
+const _GWRR = "GetWorkflowRunRequest";
+const _GWRRe = "GetWorkflowRunResponse";
+const _GWRe = "GetWorkflowResponse";
+const _GWRet = "GetWorkflowRun";
+const _ILV = "IsLatestVersion";
+const _ISE = "InternalServerException";
+const _KKI = "KmsKeyId";
+const _LC = "LoggingConfiguration";
+const _LGN = "LogGroupName";
+const _LS = "LogStream";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LTI = "ListTaskInstances";
+const _LTIR = "ListTaskInstancesRequest";
+const _LTIRi = "ListTaskInstancesResponse";
+const _LW = "ListWorkflows";
+const _LWR = "ListWorkflowsRequest";
+const _LWRR = "ListWorkflowRunsRequest";
+const _LWRRi = "ListWorkflowRunsResponse";
+const _LWRi = "ListWorkflowsResponse";
+const _LWRis = "ListWorkflowRuns";
+const _LWV = "ListWorkflowVersions";
+const _LWVR = "ListWorkflowVersionsRequest";
+const _LWVRi = "ListWorkflowVersionsResponse";
+const _M = "Message";
+const _MA = "ModifiedAt";
+const _MR = "MaxResults";
+const _N = "Name";
+const _NC = "NetworkConfiguration";
+const _NT = "NextToken";
+const _OK = "ObjectKey";
+const _OM = "ObjectMap";
+const _ON = "OperatorName";
+const _OP = "OverrideParameters";
+const _OTE = "OperationTimeoutException";
+const _QC = "QuotaCode";
+const _R = "Reason";
+const _RA = "RoleArn";
+const _RAS = "RetryAfterSeconds";
+const _RA_ = "Retry-After";
+const _RAe = "ResourceArn";
+const _RD = "RunDetail";
+const _RDS = "RunDetailSummary";
+const _RI = "ResourceId";
+const _RIe = "RevisionId";
+const _RIu = "RunId";
+const _RNFE = "ResourceNotFoundException";
+const _RS = "RunState";
+const _RT = "ResourceType";
+const _RTu = "RunType";
+const _S = "Status";
+const _SA = "StartedAt";
+const _SC = "ScheduleConfiguration";
+const _SCe = "ServiceCode";
+const _SGI = "SecurityGroupIds";
+const _SI = "SubnetIds";
+const _SO = "StartedOn";
+const _SQEE = "ServiceQuotaExceededException";
+const _SWR = "StartWorkflowRun";
+const _SWRR = "StartWorkflowRunRequest";
+const _SWRRt = "StartWorkflowRunResponse";
+const _SWRRto = "StopWorkflowRunRequest";
+const _SWRRtop = "StopWorkflowRunResponse";
+const _SWRt = "StopWorkflowRun";
+const _T = "Tags";
+const _TE = "ThrottlingException";
+const _TI = "TaskId";
+const _TII = "TaskInstanceId";
+const _TIS = "TaskInstanceSummary";
+const _TISa = "TaskInstanceSummaries";
+const _TIa = "TaskInstances";
+const _TK = "TagKeys";
+const _TM = "TriggerMode";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _Ty = "Type";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _UW = "UpdateWorkflow";
+const _UWR = "UpdateWorkflowRequest";
+const _UWRp = "UpdateWorkflowResponse";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFa = "ValidationExceptionFields";
+const _VI = "VersionId";
+const _W = "Warnings";
+const _WA = "WorkflowArn";
+const _WD = "WorkflowDefinition";
+const _WR = "WorkflowRuns";
+const _WRD = "WorkflowRunDetail";
+const _WRS = "WorkflowRunSummary";
+const _WRSo = "WorkflowRunSummaries";
+const _WS = "WorkflowStatus";
+const _WSo = "WorkflowSummary";
+const _WSor = "WorkflowSummaries";
+const _WV = "WorkflowVersion";
+const _WVS = "WorkflowVersionSummary";
+const _WVSo = "WorkflowVersionSummaries";
+const _WVo = "WorkflowVersions";
+const _Wo = "Workflows";
+const _X = "Xcom";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.mwaaserverless";
+const _tK = "tagKeys";
+const _wV = "workflowVersion";
+const n0 = "com.amazonaws.mwaaserverless";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M, _RI, _RT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateWorkflowRequest = [
+    3,
+    n0,
+    _CWR,
+    0,
+    [_N, _CT, _DSL, _RA, _D, _EC, _LC, _EV, _NC, _T, _TM],
+    [
+        0,
+        [0, 4],
+        () => DefinitionS3Location,
+        0,
+        0,
+        () => EncryptionConfiguration,
+        () => LoggingConfiguration,
+        1,
+        () => NetworkConfiguration,
+        128 | 0,
+        0,
+    ],
+];
+var CreateWorkflowResponse = [
+    3,
+    n0,
+    _CWRr,
+    0,
+    [_WA, _CA, _RIe, _WS, _WV, _ILV, _W],
+    [0, 5, 0, 0, 0, 2, 64 | 0],
+];
+var DefinitionS3Location = [3, n0, _DSL, 0, [_B, _OK, _VI], [0, 0, 0]];
+var DeleteWorkflowRequest = [
+    3,
+    n0,
+    _DWR,
+    0,
+    [_WA, _WV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _wV,
+            },
+        ],
+    ],
+];
+var DeleteWorkflowResponse = [3, n0, _DWRe, 0, [_WA, _WV], [0, 0]];
+var EncryptionConfiguration = [3, n0, _EC, 0, [_Ty, _KKI], [0, 0]];
+var GetTaskInstanceRequest = [
+    3,
+    n0,
+    _GTIR,
+    0,
+    [_WA, _TII, _RIu],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetTaskInstanceResponse = [
+    3,
+    n0,
+    _GTIRe,
+    0,
+    [_WA, _RIu, _TII, _WV, _S, _DIS, _ON, _MA, _EA, _SA, _AN, _EM, _TI, _LS, _X],
+    [0, 0, 0, 0, 0, 1, 0, 5, 5, 5, 1, 0, 0, 0, 128 | 0],
+];
+var GetWorkflowRequest = [
+    3,
+    n0,
+    _GWR,
+    0,
+    [_WA, _WV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _wV,
+            },
+        ],
+    ],
+];
+var GetWorkflowResponse = [
+    3,
+    n0,
+    _GWRe,
+    0,
+    [_WA, _WV, _N, _D, _CA, _MA, _EC, _LC, _EV, _WS, _DSL, _SC, _RA, _NC, _TM, _WD],
+    [
+        0,
+        0,
+        0,
+        0,
+        5,
+        5,
+        () => EncryptionConfiguration,
+        () => LoggingConfiguration,
+        1,
+        0,
+        () => DefinitionS3Location,
+        () => ScheduleConfiguration,
+        0,
+        () => NetworkConfiguration,
+        0,
+        0,
+    ],
+];
+var GetWorkflowRunRequest = [
+    3,
+    n0,
+    _GWRR,
+    0,
+    [_WA, _RIu],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetWorkflowRunResponse = [
+    3,
+    n0,
+    _GWRRe,
+    0,
+    [_WA, _WV, _RIu, _RTu, _OP, _RD],
+    [0, 0, 0, 0, [() => ObjectMap, 0], () => WorkflowRunDetail],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M, _RAS],
+    [
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA_,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_T], [128 | 0]];
+var ListTaskInstancesRequest = [
+    3,
+    n0,
+    _LTIR,
+    0,
+    [_WA, _RIu, _MR, _NT],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var ListTaskInstancesResponse = [
+    3,
+    n0,
+    _LTIRi,
+    0,
+    [_TIa, _NT],
+    [() => TaskInstanceSummaries, 0],
+];
+var ListWorkflowRunsRequest = [
+    3,
+    n0,
+    _LWRR,
+    0,
+    [_MR, _NT, _WA, _WV],
+    [
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _wV,
+            },
+        ],
+    ],
+];
+var ListWorkflowRunsResponse = [
+    3,
+    n0,
+    _LWRRi,
+    0,
+    [_WR, _NT],
+    [() => WorkflowRunSummaries, 0],
+];
+var ListWorkflowsRequest = [
+    3,
+    n0,
+    _LWR,
+    0,
+    [_MR, _NT],
+    [
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var ListWorkflowsResponse = [3, n0, _LWRi, 0, [_Wo, _NT], [() => WorkflowSummaries, 0]];
+var ListWorkflowVersionsRequest = [
+    3,
+    n0,
+    _LWVR,
+    0,
+    [_MR, _NT, _WA],
+    [
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [0, 1],
+    ],
+];
+var ListWorkflowVersionsResponse = [
+    3,
+    n0,
+    _LWVRi,
+    0,
+    [_WVo, _NT],
+    [() => WorkflowVersionSummaries, 0],
+];
+var LoggingConfiguration = [3, n0, _LC, 0, [_LGN], [0]];
+var NetworkConfiguration = [3, n0, _NC, 0, [_SGI, _SI], [64 | 0, 64 | 0]];
+var OperationTimeoutException = [
+    -3,
+    n0,
+    _OTE,
+    {
+        [_e]: _s,
+        [_hE]: 504,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(OperationTimeoutException, OperationTimeoutException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _RI, _RT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RunDetailSummary = [3, n0, _RDS, 0, [_S, _CO, _SA, _EA], [0, 5, 5, 5]];
+var ScheduleConfiguration = [3, n0, _SC, 0, [_CEr], [0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M, _RI, _RT, _SCe, _QC],
+    [0, 0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StartWorkflowRunRequest = [
+    3,
+    n0,
+    _SWRR,
+    0,
+    [_WA, _CT, _OP, _WV],
+    [[0, 1], [0, 4], [() => ObjectMap, 0], 0],
+];
+var StartWorkflowRunResponse = [3, n0, _SWRRt, 0, [_RIu, _S, _SA], [0, 0, 5]];
+var StopWorkflowRunRequest = [
+    3,
+    n0,
+    _SWRRto,
+    0,
+    [_WA, _RIu],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var StopWorkflowRunResponse = [3, n0, _SWRRtop, 0, [_WA, _WV, _RIu, _S], [0, 0, 0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RAe, _T], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TaskInstanceSummary = [
+    3,
+    n0,
+    _TIS,
+    0,
+    [_WA, _WV, _RIu, _TII, _S, _DIS, _ON],
+    [0, 0, 0, 0, 0, 1, 0],
+];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M, _SCe, _QC, _RAS],
+    [
+        0,
+        0,
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA_,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_RAe, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateWorkflowRequest = [
+    3,
+    n0,
+    _UWR,
+    0,
+    [_WA, _DSL, _RA, _D, _LC, _EV, _NC, _TM],
+    [[0, 1], () => DefinitionS3Location, 0, 0, () => LoggingConfiguration, 1, () => NetworkConfiguration, 0],
+];
+var UpdateWorkflowResponse = [3, n0, _UWRp, 0, [_WA, _MA, _WV, _W], [0, 5, 0, 64 | 0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _R, _FL],
+    [0, 0, () => ValidationExceptionFields],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_N, _M], [0, 0]];
+var WorkflowRunDetail = [
+    3,
+    n0,
+    _WRD,
+    0,
+    [_WA, _WV, _RIu, _RTu, _SO, _CA, _COo, _MA, _Du, _EM, _TIa, _RS],
+    [0, 0, 0, 0, 5, 5, 5, 5, 1, 0, 64 | 0, 0],
+];
+var WorkflowRunSummary = [
+    3,
+    n0,
+    _WRS,
+    0,
+    [_RIu, _WA, _WV, _RTu, _RDS],
+    [0, 0, 0, 0, () => RunDetailSummary],
+];
+var WorkflowSummary = [
+    3,
+    n0,
+    _WSo,
+    0,
+    [_WA, _WV, _N, _D, _CA, _MA, _WS, _TM],
+    [0, 0, 0, 0, 5, 5, 0, 0],
+];
+var WorkflowVersionSummary = [
+    3,
+    n0,
+    _WVS,
+    0,
+    [_WV, _WA, _ILV, _CA, _MA, _DSL, _SC, _TM],
+    [0, 0, 2, 5, 5, () => DefinitionS3Location, () => ScheduleConfiguration, 0],
+];
+var MWAAServerlessServiceException = [-3, _sm, "MWAAServerlessServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(MWAAServerlessServiceException, MWAAServerlessServiceException$1);
+var TaskInstanceSummaries = [1, n0, _TISa, 0, () => TaskInstanceSummary];
+var ValidationExceptionFields = [1, n0, _VEFa, 0, () => ValidationExceptionField];
+var WorkflowRunSummaries = [1, n0, _WRSo, 0, () => WorkflowRunSummary];
+var WorkflowSummaries = [1, n0, _WSor, 0, () => WorkflowSummary];
+var WorkflowVersionSummaries = [1, n0, _WVSo, 0, () => WorkflowVersionSummary];
+var ObjectMap = [2, n0, _OM, 8, 0, 15];
+var CreateWorkflow = [
+    9,
+    n0,
+    _CW,
+    {
+        [_h]: ["POST", "/workflows", 200],
+    },
+    () => CreateWorkflowRequest,
+    () => CreateWorkflowResponse,
+];
+var DeleteWorkflow = [
+    9,
+    n0,
+    _DW,
+    {
+        [_h]: ["DELETE", "/workflows/{WorkflowArn}", 200],
+    },
+    () => DeleteWorkflowRequest,
+    () => DeleteWorkflowResponse,
+];
+var GetTaskInstance = [
+    9,
+    n0,
+    _GTI,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}/runs/{RunId}/tasks/{TaskInstanceId}", 200],
+    },
+    () => GetTaskInstanceRequest,
+    () => GetTaskInstanceResponse,
+];
+var GetWorkflow = [
+    9,
+    n0,
+    _GW,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}", 200],
+    },
+    () => GetWorkflowRequest,
+    () => GetWorkflowResponse,
+];
+var GetWorkflowRun = [
+    9,
+    n0,
+    _GWRet,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}/runs/{RunId}", 200],
+    },
+    () => GetWorkflowRunRequest,
+    () => GetWorkflowRunResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{ResourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var ListTaskInstances = [
+    9,
+    n0,
+    _LTI,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}/runs/{RunId}/tasks", 200],
+    },
+    () => ListTaskInstancesRequest,
+    () => ListTaskInstancesResponse,
+];
+var ListWorkflowRuns = [
+    9,
+    n0,
+    _LWRis,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}/runs", 200],
+    },
+    () => ListWorkflowRunsRequest,
+    () => ListWorkflowRunsResponse,
+];
+var ListWorkflows = [
+    9,
+    n0,
+    _LW,
+    {
+        [_h]: ["GET", "/workflows", 200],
+    },
+    () => ListWorkflowsRequest,
+    () => ListWorkflowsResponse,
+];
+var ListWorkflowVersions = [
+    9,
+    n0,
+    _LWV,
+    {
+        [_h]: ["GET", "/workflows/{WorkflowArn}/versions", 200],
+    },
+    () => ListWorkflowVersionsRequest,
+    () => ListWorkflowVersionsResponse,
+];
+var StartWorkflowRun = [
+    9,
+    n0,
+    _SWR,
+    {
+        [_h]: ["POST", "/workflows/{WorkflowArn}/runs", 200],
+    },
+    () => StartWorkflowRunRequest,
+    () => StartWorkflowRunResponse,
+];
+var StopWorkflowRun = [
+    9,
+    n0,
+    _SWRt,
+    {
+        [_h]: ["DELETE", "/workflows/{WorkflowArn}/runs/{RunId}", 200],
+    },
+    () => StopWorkflowRunRequest,
+    () => StopWorkflowRunResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{ResourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{ResourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateWorkflow = [
+    9,
+    n0,
+    _UW,
+    {
+        [_h]: ["PUT", "/workflows/{WorkflowArn}", 200],
+    },
+    () => UpdateWorkflowRequest,
+    () => UpdateWorkflowResponse,
+];
+
+class CreateWorkflowCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "CreateWorkflow", {})
+    .n("MWAAServerlessClient", "CreateWorkflowCommand")
+    .sc(CreateWorkflow)
+    .build() {
+}
+
+class DeleteWorkflowCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "DeleteWorkflow", {})
+    .n("MWAAServerlessClient", "DeleteWorkflowCommand")
+    .sc(DeleteWorkflow)
+    .build() {
+}
+
+class GetTaskInstanceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "GetTaskInstance", {})
+    .n("MWAAServerlessClient", "GetTaskInstanceCommand")
+    .sc(GetTaskInstance)
+    .build() {
+}
+
+class GetWorkflowCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "GetWorkflow", {})
+    .n("MWAAServerlessClient", "GetWorkflowCommand")
+    .sc(GetWorkflow)
+    .build() {
+}
+
+class GetWorkflowRunCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "GetWorkflowRun", {})
+    .n("MWAAServerlessClient", "GetWorkflowRunCommand")
+    .sc(GetWorkflowRun)
+    .build() {
+}
+
+class ListTagsForResourceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "ListTagsForResource", {})
+    .n("MWAAServerlessClient", "ListTagsForResourceCommand")
+    .sc(ListTagsForResource)
+    .build() {
+}
+
+class ListTaskInstancesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "ListTaskInstances", {})
+    .n("MWAAServerlessClient", "ListTaskInstancesCommand")
+    .sc(ListTaskInstances)
+    .build() {
+}
+
+class ListWorkflowRunsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "ListWorkflowRuns", {})
+    .n("MWAAServerlessClient", "ListWorkflowRunsCommand")
+    .sc(ListWorkflowRuns)
+    .build() {
+}
+
+class ListWorkflowsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "ListWorkflows", {})
+    .n("MWAAServerlessClient", "ListWorkflowsCommand")
+    .sc(ListWorkflows)
+    .build() {
+}
+
+class ListWorkflowVersionsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "ListWorkflowVersions", {})
+    .n("MWAAServerlessClient", "ListWorkflowVersionsCommand")
+    .sc(ListWorkflowVersions)
+    .build() {
+}
+
+class StartWorkflowRunCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "StartWorkflowRun", {})
+    .n("MWAAServerlessClient", "StartWorkflowRunCommand")
+    .sc(StartWorkflowRun)
+    .build() {
+}
+
+class StopWorkflowRunCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "StopWorkflowRun", {})
+    .n("MWAAServerlessClient", "StopWorkflowRunCommand")
+    .sc(StopWorkflowRun)
+    .build() {
+}
+
+class TagResourceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "TagResource", {})
+    .n("MWAAServerlessClient", "TagResourceCommand")
+    .sc(TagResource)
+    .build() {
+}
+
+class UntagResourceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "UntagResource", {})
+    .n("MWAAServerlessClient", "UntagResourceCommand")
+    .sc(UntagResource)
+    .build() {
+}
+
+class UpdateWorkflowCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonMWAAServerless", "UpdateWorkflow", {})
+    .n("MWAAServerlessClient", "UpdateWorkflowCommand")
+    .sc(UpdateWorkflow)
+    .build() {
+}
+
+const commands = {
+    CreateWorkflowCommand,
+    DeleteWorkflowCommand,
+    GetTaskInstanceCommand,
+    GetWorkflowCommand,
+    GetWorkflowRunCommand,
+    ListTagsForResourceCommand,
+    ListTaskInstancesCommand,
+    ListWorkflowRunsCommand,
+    ListWorkflowsCommand,
+    ListWorkflowVersionsCommand,
+    StartWorkflowRunCommand,
+    StopWorkflowRunCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UpdateWorkflowCommand,
+};
+class MWAAServerless extends MWAAServerlessClient {
+}
+smithyClient.createAggregatedClient(commands, MWAAServerless);
+
+const paginateListTaskInstances = core.createPaginator(MWAAServerlessClient, ListTaskInstancesCommand, "NextToken", "NextToken", "MaxResults");
+
+const paginateListWorkflowRuns = core.createPaginator(MWAAServerlessClient, ListWorkflowRunsCommand, "NextToken", "NextToken", "MaxResults");
+
+const paginateListWorkflowVersions = core.createPaginator(MWAAServerlessClient, ListWorkflowVersionsCommand, "NextToken", "NextToken", "MaxResults");
+
+const paginateListWorkflows = core.createPaginator(MWAAServerlessClient, ListWorkflowsCommand, "NextToken", "NextToken", "MaxResults");
+
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
+});
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.AccessDeniedException = AccessDeniedException$1;
+exports.ConflictException = ConflictException$1;
+exports.CreateWorkflowCommand = CreateWorkflowCommand;
+exports.DeleteWorkflowCommand = DeleteWorkflowCommand;
+exports.EncryptionType = EncryptionType;
+exports.GetTaskInstanceCommand = GetTaskInstanceCommand;
+exports.GetWorkflowCommand = GetWorkflowCommand;
+exports.GetWorkflowRunCommand = GetWorkflowRunCommand;
+exports.InternalServerException = InternalServerException$1;
+exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTaskInstancesCommand = ListTaskInstancesCommand;
+exports.ListWorkflowRunsCommand = ListWorkflowRunsCommand;
+exports.ListWorkflowVersionsCommand = ListWorkflowVersionsCommand;
+exports.ListWorkflowsCommand = ListWorkflowsCommand;
+exports.MWAAServerless = MWAAServerless;
+exports.MWAAServerlessClient = MWAAServerlessClient;
+exports.MWAAServerlessServiceException = MWAAServerlessServiceException$1;
+exports.OperationTimeoutException = OperationTimeoutException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.RunType = RunType;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
+exports.StartWorkflowRunCommand = StartWorkflowRunCommand;
+exports.StopWorkflowRunCommand = StopWorkflowRunCommand;
+exports.TagResourceCommand = TagResourceCommand;
+exports.TaskInstanceStatus = TaskInstanceStatus;
+exports.ThrottlingException = ThrottlingException$1;
+exports.UntagResourceCommand = UntagResourceCommand;
+exports.UpdateWorkflowCommand = UpdateWorkflowCommand;
+exports.ValidationException = ValidationException$1;
+exports.ValidationExceptionReason = ValidationExceptionReason;
+exports.WorkflowRunStatus = WorkflowRunStatus;
+exports.WorkflowStatus = WorkflowStatus;
+exports.paginateListTaskInstances = paginateListTaskInstances;
+exports.paginateListWorkflowRuns = paginateListWorkflowRuns;
+exports.paginateListWorkflowVersions = paginateListWorkflowVersions;
+exports.paginateListWorkflows = paginateListWorkflows;