@aws-sdk/client-codedeploy 3.1074.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,21 +1,57 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultCodeDeployHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { AddTagsToOnPremisesInstances$, BatchGetApplicationRevisions$, BatchGetApplications$, BatchGetDeploymentGroups$, BatchGetDeploymentInstances$, BatchGetDeployments$, BatchGetDeploymentTargets$, BatchGetOnPremisesInstances$, ContinueDeployment$, CreateApplication$, CreateDeployment$, CreateDeploymentConfig$, CreateDeploymentGroup$, DeleteApplication$, DeleteDeploymentConfig$, DeleteDeploymentGroup$, DeleteGitHubAccountToken$, DeleteResourcesByExternalId$, DeregisterOnPremisesInstance$, GetApplication$, GetApplicationRevision$, GetDeployment$, GetDeploymentConfig$, GetDeploymentGroup$, GetDeploymentInstance$, GetDeploymentTarget$, GetOnPremisesInstance$, ListApplicationRevisions$, ListApplications$, ListDeploymentConfigs$, ListDeploymentGroups$, ListDeploymentInstances$, ListDeployments$, ListDeploymentTargets$, ListGitHubAccountTokenNames$, ListOnPremisesInstances$, ListTagsForResource$, PutLifecycleEventHookExecutionStatus$, RegisterApplicationRevision$, RegisterOnPremisesInstance$, RemoveTagsFromOnPremisesInstances$, SkipWaitTimeForInstanceTermination$, StopDeployment$, TagResource$, UntagResource$, UpdateApplication$, UpdateDeploymentGroup$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { CodeDeployServiceException } = require("./models/CodeDeployServiceException");
-exports.CodeDeployServiceException = CodeDeployServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsJson1_1Protocol } = require("@aws-sdk/core/protocols");
+
+const defaultCodeDeployHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "codedeploy",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultCodeDeployHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +67,3587 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://codedeploy-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://codedeploy-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://codedeploy.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://codedeploy.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 12, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 10,
+    5, r + 8, r + 9,
+    4, 10, 9,
+    6, r + 6, r + 7,
+    5, 11, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 13,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class CodeDeployServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, CodeDeployServiceException.prototype);
+    }
+}
+
+class InstanceLimitExceededException extends CodeDeployServiceException {
+    name = "InstanceLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceLimitExceededException.prototype);
+    }
+}
+class InstanceNameRequiredException extends CodeDeployServiceException {
+    name = "InstanceNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceNameRequiredException.prototype);
+    }
+}
+class InstanceNotRegisteredException extends CodeDeployServiceException {
+    name = "InstanceNotRegisteredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceNotRegisteredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceNotRegisteredException.prototype);
+    }
+}
+class InvalidInstanceNameException extends CodeDeployServiceException {
+    name = "InvalidInstanceNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidInstanceNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidInstanceNameException.prototype);
+    }
+}
+class InvalidTagException extends CodeDeployServiceException {
+    name = "InvalidTagException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagException.prototype);
+    }
+}
+class TagLimitExceededException extends CodeDeployServiceException {
+    name = "TagLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagLimitExceededException.prototype);
+    }
+}
+class TagRequiredException extends CodeDeployServiceException {
+    name = "TagRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagRequiredException.prototype);
+    }
+}
+class AlarmsLimitExceededException extends CodeDeployServiceException {
+    name = "AlarmsLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AlarmsLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AlarmsLimitExceededException.prototype);
+    }
+}
+class ApplicationAlreadyExistsException extends CodeDeployServiceException {
+    name = "ApplicationAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApplicationAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApplicationAlreadyExistsException.prototype);
+    }
+}
+class ApplicationDoesNotExistException extends CodeDeployServiceException {
+    name = "ApplicationDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApplicationDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApplicationDoesNotExistException.prototype);
+    }
+}
+class ApplicationLimitExceededException extends CodeDeployServiceException {
+    name = "ApplicationLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApplicationLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApplicationLimitExceededException.prototype);
+    }
+}
+class ApplicationNameRequiredException extends CodeDeployServiceException {
+    name = "ApplicationNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApplicationNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApplicationNameRequiredException.prototype);
+    }
+}
+class ArnNotSupportedException extends CodeDeployServiceException {
+    name = "ArnNotSupportedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ArnNotSupportedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ArnNotSupportedException.prototype);
+    }
+}
+class BatchLimitExceededException extends CodeDeployServiceException {
+    name = "BatchLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BatchLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BatchLimitExceededException.prototype);
+    }
+}
+class InvalidApplicationNameException extends CodeDeployServiceException {
+    name = "InvalidApplicationNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApplicationNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApplicationNameException.prototype);
+    }
+}
+class InvalidRevisionException extends CodeDeployServiceException {
+    name = "InvalidRevisionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRevisionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRevisionException.prototype);
+    }
+}
+class RevisionRequiredException extends CodeDeployServiceException {
+    name = "RevisionRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RevisionRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RevisionRequiredException.prototype);
+    }
+}
+class DeploymentConfigDoesNotExistException extends CodeDeployServiceException {
+    name = "DeploymentConfigDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentConfigDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentConfigDoesNotExistException.prototype);
+    }
+}
+class DeploymentGroupNameRequiredException extends CodeDeployServiceException {
+    name = "DeploymentGroupNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentGroupNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentGroupNameRequiredException.prototype);
+    }
+}
+class InvalidDeploymentGroupNameException extends CodeDeployServiceException {
+    name = "InvalidDeploymentGroupNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentGroupNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentGroupNameException.prototype);
+    }
+}
+class DeploymentDoesNotExistException extends CodeDeployServiceException {
+    name = "DeploymentDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentDoesNotExistException.prototype);
+    }
+}
+class DeploymentIdRequiredException extends CodeDeployServiceException {
+    name = "DeploymentIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentIdRequiredException.prototype);
+    }
+}
+class InstanceIdRequiredException extends CodeDeployServiceException {
+    name = "InstanceIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceIdRequiredException.prototype);
+    }
+}
+class InvalidComputePlatformException extends CodeDeployServiceException {
+    name = "InvalidComputePlatformException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidComputePlatformException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidComputePlatformException.prototype);
+    }
+}
+class InvalidDeploymentIdException extends CodeDeployServiceException {
+    name = "InvalidDeploymentIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentIdException.prototype);
+    }
+}
+class DeploymentNotStartedException extends CodeDeployServiceException {
+    name = "DeploymentNotStartedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentNotStartedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentNotStartedException.prototype);
+    }
+}
+class DeploymentTargetDoesNotExistException extends CodeDeployServiceException {
+    name = "DeploymentTargetDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentTargetDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentTargetDoesNotExistException.prototype);
+    }
+}
+class DeploymentTargetIdRequiredException extends CodeDeployServiceException {
+    name = "DeploymentTargetIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentTargetIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentTargetIdRequiredException.prototype);
+    }
+}
+class DeploymentTargetListSizeExceededException extends CodeDeployServiceException {
+    name = "DeploymentTargetListSizeExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentTargetListSizeExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentTargetListSizeExceededException.prototype);
+    }
+}
+class InstanceDoesNotExistException extends CodeDeployServiceException {
+    name = "InstanceDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceDoesNotExistException.prototype);
+    }
+}
+class InvalidDeploymentTargetIdException extends CodeDeployServiceException {
+    name = "InvalidDeploymentTargetIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentTargetIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentTargetIdException.prototype);
+    }
+}
+class BucketNameFilterRequiredException extends CodeDeployServiceException {
+    name = "BucketNameFilterRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BucketNameFilterRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BucketNameFilterRequiredException.prototype);
+    }
+}
+class DeploymentAlreadyCompletedException extends CodeDeployServiceException {
+    name = "DeploymentAlreadyCompletedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentAlreadyCompletedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentAlreadyCompletedException.prototype);
+    }
+}
+class DeploymentIsNotInReadyStateException extends CodeDeployServiceException {
+    name = "DeploymentIsNotInReadyStateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentIsNotInReadyStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentIsNotInReadyStateException.prototype);
+    }
+}
+class InvalidDeploymentStatusException extends CodeDeployServiceException {
+    name = "InvalidDeploymentStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentStatusException.prototype);
+    }
+}
+class InvalidDeploymentWaitTypeException extends CodeDeployServiceException {
+    name = "InvalidDeploymentWaitTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentWaitTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentWaitTypeException.prototype);
+    }
+}
+class UnsupportedActionForDeploymentTypeException extends CodeDeployServiceException {
+    name = "UnsupportedActionForDeploymentTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedActionForDeploymentTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedActionForDeploymentTypeException.prototype);
+    }
+}
+class InvalidTagsToAddException extends CodeDeployServiceException {
+    name = "InvalidTagsToAddException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagsToAddException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagsToAddException.prototype);
+    }
+}
+class DeploymentGroupDoesNotExistException extends CodeDeployServiceException {
+    name = "DeploymentGroupDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentGroupDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentGroupDoesNotExistException.prototype);
+    }
+}
+class DeploymentLimitExceededException extends CodeDeployServiceException {
+    name = "DeploymentLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentLimitExceededException.prototype);
+    }
+}
+class DescriptionTooLongException extends CodeDeployServiceException {
+    name = "DescriptionTooLongException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DescriptionTooLongException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DescriptionTooLongException.prototype);
+    }
+}
+class InvalidAlarmConfigException extends CodeDeployServiceException {
+    name = "InvalidAlarmConfigException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidAlarmConfigException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidAlarmConfigException.prototype);
+    }
+}
+class InvalidAutoRollbackConfigException extends CodeDeployServiceException {
+    name = "InvalidAutoRollbackConfigException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidAutoRollbackConfigException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidAutoRollbackConfigException.prototype);
+    }
+}
+class InvalidAutoScalingGroupException extends CodeDeployServiceException {
+    name = "InvalidAutoScalingGroupException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidAutoScalingGroupException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidAutoScalingGroupException.prototype);
+    }
+}
+class InvalidDeploymentConfigNameException extends CodeDeployServiceException {
+    name = "InvalidDeploymentConfigNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentConfigNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentConfigNameException.prototype);
+    }
+}
+class InvalidFileExistsBehaviorException extends CodeDeployServiceException {
+    name = "InvalidFileExistsBehaviorException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidFileExistsBehaviorException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidFileExistsBehaviorException.prototype);
+    }
+}
+class InvalidGitHubAccountTokenException extends CodeDeployServiceException {
+    name = "InvalidGitHubAccountTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidGitHubAccountTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidGitHubAccountTokenException.prototype);
+    }
+}
+class InvalidIgnoreApplicationStopFailuresValueException extends CodeDeployServiceException {
+    name = "InvalidIgnoreApplicationStopFailuresValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidIgnoreApplicationStopFailuresValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidIgnoreApplicationStopFailuresValueException.prototype);
+    }
+}
+class InvalidLoadBalancerInfoException extends CodeDeployServiceException {
+    name = "InvalidLoadBalancerInfoException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLoadBalancerInfoException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLoadBalancerInfoException.prototype);
+    }
+}
+class InvalidRoleException extends CodeDeployServiceException {
+    name = "InvalidRoleException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRoleException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRoleException.prototype);
+    }
+}
+class InvalidTargetInstancesException extends CodeDeployServiceException {
+    name = "InvalidTargetInstancesException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetInstancesException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetInstancesException.prototype);
+    }
+}
+class InvalidTrafficRoutingConfigurationException extends CodeDeployServiceException {
+    name = "InvalidTrafficRoutingConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTrafficRoutingConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTrafficRoutingConfigurationException.prototype);
+    }
+}
+class InvalidUpdateOutdatedInstancesOnlyValueException extends CodeDeployServiceException {
+    name = "InvalidUpdateOutdatedInstancesOnlyValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidUpdateOutdatedInstancesOnlyValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidUpdateOutdatedInstancesOnlyValueException.prototype);
+    }
+}
+class RevisionDoesNotExistException extends CodeDeployServiceException {
+    name = "RevisionDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RevisionDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RevisionDoesNotExistException.prototype);
+    }
+}
+class ThrottlingException extends CodeDeployServiceException {
+    name = "ThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+class DeploymentConfigAlreadyExistsException extends CodeDeployServiceException {
+    name = "DeploymentConfigAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentConfigAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentConfigAlreadyExistsException.prototype);
+    }
+}
+class DeploymentConfigLimitExceededException extends CodeDeployServiceException {
+    name = "DeploymentConfigLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentConfigLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentConfigLimitExceededException.prototype);
+    }
+}
+class DeploymentConfigNameRequiredException extends CodeDeployServiceException {
+    name = "DeploymentConfigNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentConfigNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentConfigNameRequiredException.prototype);
+    }
+}
+class InvalidMinimumHealthyHostValueException extends CodeDeployServiceException {
+    name = "InvalidMinimumHealthyHostValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMinimumHealthyHostValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMinimumHealthyHostValueException.prototype);
+    }
+}
+class InvalidZonalDeploymentConfigurationException extends CodeDeployServiceException {
+    name = "InvalidZonalDeploymentConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidZonalDeploymentConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidZonalDeploymentConfigurationException.prototype);
+    }
+}
+class DeploymentGroupAlreadyExistsException extends CodeDeployServiceException {
+    name = "DeploymentGroupAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentGroupAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentGroupAlreadyExistsException.prototype);
+    }
+}
+class DeploymentGroupLimitExceededException extends CodeDeployServiceException {
+    name = "DeploymentGroupLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentGroupLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentGroupLimitExceededException.prototype);
+    }
+}
+class ECSServiceMappingLimitExceededException extends CodeDeployServiceException {
+    name = "ECSServiceMappingLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ECSServiceMappingLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ECSServiceMappingLimitExceededException.prototype);
+    }
+}
+class InvalidBlueGreenDeploymentConfigurationException extends CodeDeployServiceException {
+    name = "InvalidBlueGreenDeploymentConfigurationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidBlueGreenDeploymentConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidBlueGreenDeploymentConfigurationException.prototype);
+    }
+}
+class InvalidDeploymentStyleException extends CodeDeployServiceException {
+    name = "InvalidDeploymentStyleException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentStyleException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentStyleException.prototype);
+    }
+}
+class InvalidEC2TagCombinationException extends CodeDeployServiceException {
+    name = "InvalidEC2TagCombinationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidEC2TagCombinationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidEC2TagCombinationException.prototype);
+    }
+}
+class InvalidEC2TagException extends CodeDeployServiceException {
+    name = "InvalidEC2TagException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidEC2TagException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidEC2TagException.prototype);
+    }
+}
+class InvalidECSServiceException extends CodeDeployServiceException {
+    name = "InvalidECSServiceException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidECSServiceException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidECSServiceException.prototype);
+    }
+}
+class InvalidInputException extends CodeDeployServiceException {
+    name = "InvalidInputException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidInputException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidInputException.prototype);
+    }
+}
+class InvalidOnPremisesTagCombinationException extends CodeDeployServiceException {
+    name = "InvalidOnPremisesTagCombinationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOnPremisesTagCombinationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOnPremisesTagCombinationException.prototype);
+    }
+}
+class InvalidTargetGroupPairException extends CodeDeployServiceException {
+    name = "InvalidTargetGroupPairException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetGroupPairException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetGroupPairException.prototype);
+    }
+}
+class InvalidTriggerConfigException extends CodeDeployServiceException {
+    name = "InvalidTriggerConfigException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTriggerConfigException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTriggerConfigException.prototype);
+    }
+}
+class LifecycleHookLimitExceededException extends CodeDeployServiceException {
+    name = "LifecycleHookLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LifecycleHookLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LifecycleHookLimitExceededException.prototype);
+    }
+}
+class RoleRequiredException extends CodeDeployServiceException {
+    name = "RoleRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RoleRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RoleRequiredException.prototype);
+    }
+}
+class TagSetListLimitExceededException extends CodeDeployServiceException {
+    name = "TagSetListLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagSetListLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagSetListLimitExceededException.prototype);
+    }
+}
+class TriggerTargetsLimitExceededException extends CodeDeployServiceException {
+    name = "TriggerTargetsLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TriggerTargetsLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TriggerTargetsLimitExceededException.prototype);
+    }
+}
+class DeploymentConfigInUseException extends CodeDeployServiceException {
+    name = "DeploymentConfigInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DeploymentConfigInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeploymentConfigInUseException.prototype);
+    }
+}
+class InvalidOperationException extends CodeDeployServiceException {
+    name = "InvalidOperationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOperationException.prototype);
+    }
+}
+class GitHubAccountTokenDoesNotExistException extends CodeDeployServiceException {
+    name = "GitHubAccountTokenDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "GitHubAccountTokenDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, GitHubAccountTokenDoesNotExistException.prototype);
+    }
+}
+class GitHubAccountTokenNameRequiredException extends CodeDeployServiceException {
+    name = "GitHubAccountTokenNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "GitHubAccountTokenNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, GitHubAccountTokenNameRequiredException.prototype);
+    }
+}
+class InvalidGitHubAccountTokenNameException extends CodeDeployServiceException {
+    name = "InvalidGitHubAccountTokenNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidGitHubAccountTokenNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidGitHubAccountTokenNameException.prototype);
+    }
+}
+class OperationNotSupportedException extends CodeDeployServiceException {
+    name = "OperationNotSupportedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "OperationNotSupportedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OperationNotSupportedException.prototype);
+    }
+}
+class ResourceValidationException extends CodeDeployServiceException {
+    name = "ResourceValidationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceValidationException.prototype);
+    }
+}
+class InvalidBucketNameFilterException extends CodeDeployServiceException {
+    name = "InvalidBucketNameFilterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidBucketNameFilterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidBucketNameFilterException.prototype);
+    }
+}
+class InvalidDeployedStateFilterException extends CodeDeployServiceException {
+    name = "InvalidDeployedStateFilterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeployedStateFilterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeployedStateFilterException.prototype);
+    }
+}
+class InvalidKeyPrefixFilterException extends CodeDeployServiceException {
+    name = "InvalidKeyPrefixFilterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidKeyPrefixFilterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidKeyPrefixFilterException.prototype);
+    }
+}
+class InvalidNextTokenException extends CodeDeployServiceException {
+    name = "InvalidNextTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidNextTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
+    }
+}
+class InvalidSortByException extends CodeDeployServiceException {
+    name = "InvalidSortByException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSortByException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSortByException.prototype);
+    }
+}
+class InvalidSortOrderException extends CodeDeployServiceException {
+    name = "InvalidSortOrderException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSortOrderException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSortOrderException.prototype);
+    }
+}
+class InvalidDeploymentInstanceTypeException extends CodeDeployServiceException {
+    name = "InvalidDeploymentInstanceTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeploymentInstanceTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeploymentInstanceTypeException.prototype);
+    }
+}
+class InvalidInstanceStatusException extends CodeDeployServiceException {
+    name = "InvalidInstanceStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidInstanceStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidInstanceStatusException.prototype);
+    }
+}
+class InvalidInstanceTypeException extends CodeDeployServiceException {
+    name = "InvalidInstanceTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidInstanceTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidInstanceTypeException.prototype);
+    }
+}
+class InvalidTargetFilterNameException extends CodeDeployServiceException {
+    name = "InvalidTargetFilterNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetFilterNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetFilterNameException.prototype);
+    }
+}
+class InvalidExternalIdException extends CodeDeployServiceException {
+    name = "InvalidExternalIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidExternalIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidExternalIdException.prototype);
+    }
+}
+class InvalidTimeRangeException extends CodeDeployServiceException {
+    name = "InvalidTimeRangeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTimeRangeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTimeRangeException.prototype);
+    }
+}
+class InvalidRegistrationStatusException extends CodeDeployServiceException {
+    name = "InvalidRegistrationStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRegistrationStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRegistrationStatusException.prototype);
+    }
+}
+class InvalidTagFilterException extends CodeDeployServiceException {
+    name = "InvalidTagFilterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagFilterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagFilterException.prototype);
+    }
+}
+class InvalidArnException extends CodeDeployServiceException {
+    name = "InvalidArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArnException.prototype);
+    }
+}
+class ResourceArnRequiredException extends CodeDeployServiceException {
+    name = "ResourceArnRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceArnRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceArnRequiredException.prototype);
+    }
+}
+class InvalidLifecycleEventHookExecutionIdException extends CodeDeployServiceException {
+    name = "InvalidLifecycleEventHookExecutionIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLifecycleEventHookExecutionIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLifecycleEventHookExecutionIdException.prototype);
+    }
+}
+class InvalidLifecycleEventHookExecutionStatusException extends CodeDeployServiceException {
+    name = "InvalidLifecycleEventHookExecutionStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLifecycleEventHookExecutionStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLifecycleEventHookExecutionStatusException.prototype);
+    }
+}
+class LifecycleEventAlreadyCompletedException extends CodeDeployServiceException {
+    name = "LifecycleEventAlreadyCompletedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LifecycleEventAlreadyCompletedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LifecycleEventAlreadyCompletedException.prototype);
+    }
+}
+class IamArnRequiredException extends CodeDeployServiceException {
+    name = "IamArnRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IamArnRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IamArnRequiredException.prototype);
+    }
+}
+class IamSessionArnAlreadyRegisteredException extends CodeDeployServiceException {
+    name = "IamSessionArnAlreadyRegisteredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IamSessionArnAlreadyRegisteredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IamSessionArnAlreadyRegisteredException.prototype);
+    }
+}
+class IamUserArnAlreadyRegisteredException extends CodeDeployServiceException {
+    name = "IamUserArnAlreadyRegisteredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IamUserArnAlreadyRegisteredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IamUserArnAlreadyRegisteredException.prototype);
+    }
+}
+class IamUserArnRequiredException extends CodeDeployServiceException {
+    name = "IamUserArnRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IamUserArnRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IamUserArnRequiredException.prototype);
+    }
+}
+class InstanceNameAlreadyRegisteredException extends CodeDeployServiceException {
+    name = "InstanceNameAlreadyRegisteredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InstanceNameAlreadyRegisteredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InstanceNameAlreadyRegisteredException.prototype);
+    }
+}
+class InvalidIamSessionArnException extends CodeDeployServiceException {
+    name = "InvalidIamSessionArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidIamSessionArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidIamSessionArnException.prototype);
+    }
+}
+class InvalidIamUserArnException extends CodeDeployServiceException {
+    name = "InvalidIamUserArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidIamUserArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidIamUserArnException.prototype);
+    }
+}
+class MultipleIamArnsProvidedException extends CodeDeployServiceException {
+    name = "MultipleIamArnsProvidedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MultipleIamArnsProvidedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MultipleIamArnsProvidedException.prototype);
+    }
+}
+
+const _A = "Alarm";
+const _AAEE = "ApplicationAlreadyExistsException";
+const _AC = "AlarmConfiguration";
+const _ADNEE = "ApplicationDoesNotExistException";
+const _AI = "ApplicationInfo";
+const _AIL = "ApplicationsInfoList";
+const _AL = "AlarmList";
+const _ALEE = "AlarmsLimitExceededException";
+const _ALEEp = "ApplicationLimitExceededException";
+const _ANRE = "ApplicationNameRequiredException";
+const _ANSE = "ArnNotSupportedException";
+const _ARC = "AutoRollbackConfiguration";
+const _ASC = "AppSpecContent";
+const _ASG = "AutoScalingGroup";
+const _ASGL = "AutoScalingGroupList";
+const _ATTOPI = "AddTagsToOnPremisesInstances";
+const _ATTOPII = "AddTagsToOnPremisesInstancesInput";
+const _BGA = "BatchGetApplications";
+const _BGAI = "BatchGetApplicationsInput";
+const _BGAO = "BatchGetApplicationsOutput";
+const _BGAR = "BatchGetApplicationRevisions";
+const _BGARI = "BatchGetApplicationRevisionsInput";
+const _BGARO = "BatchGetApplicationRevisionsOutput";
+const _BGD = "BatchGetDeployments";
+const _BGDC = "BlueGreenDeploymentConfiguration";
+const _BGDG = "BatchGetDeploymentGroups";
+const _BGDGI = "BatchGetDeploymentGroupsInput";
+const _BGDGO = "BatchGetDeploymentGroupsOutput";
+const _BGDI = "BatchGetDeploymentsInput";
+const _BGDII = "BatchGetDeploymentInstancesInput";
+const _BGDIO = "BatchGetDeploymentInstancesOutput";
+const _BGDIa = "BatchGetDeploymentInstances";
+const _BGDO = "BatchGetDeploymentsOutput";
+const _BGDT = "BatchGetDeploymentTargets";
+const _BGDTI = "BatchGetDeploymentTargetsInput";
+const _BGDTO = "BatchGetDeploymentTargetsOutput";
+const _BGOPI = "BatchGetOnPremisesInstances";
+const _BGOPII = "BatchGetOnPremisesInstancesInput";
+const _BGOPIO = "BatchGetOnPremisesInstancesOutput";
+const _BITO = "BlueInstanceTerminationOption";
+const _BLEE = "BatchLimitExceededException";
+const _BNFRE = "BucketNameFilterRequiredException";
+const _CA = "CreateApplication";
+const _CAI = "CreateApplicationInput";
+const _CAO = "CreateApplicationOutput";
+const _CD = "ContinueDeployment";
+const _CDC = "CreateDeploymentConfig";
+const _CDCI = "CreateDeploymentConfigInput";
+const _CDCO = "CreateDeploymentConfigOutput";
+const _CDG = "CreateDeploymentGroup";
+const _CDGI = "CreateDeploymentGroupInput";
+const _CDGO = "CreateDeploymentGroupOutput";
+const _CDI = "ContinueDeploymentInput";
+const _CDIr = "CreateDeploymentInput";
+const _CDO = "CreateDeploymentOutput";
+const _CDr = "CreateDeployment";
+const _CFT = "CloudFormationTarget";
+const _D = "Diagnostics";
+const _DA = "DeleteApplication";
+const _DACE = "DeploymentAlreadyCompletedException";
+const _DAI = "DeleteApplicationInput";
+const _DCAEE = "DeploymentConfigAlreadyExistsException";
+const _DCDNEE = "DeploymentConfigDoesNotExistException";
+const _DCI = "DeploymentConfigInfo";
+const _DCIUE = "DeploymentConfigInUseException";
+const _DCLEE = "DeploymentConfigLimitExceededException";
+const _DCNRE = "DeploymentConfigNameRequiredException";
+const _DDC = "DeleteDeploymentConfig";
+const _DDCI = "DeleteDeploymentConfigInput";
+const _DDG = "DeleteDeploymentGroup";
+const _DDGI = "DeleteDeploymentGroupInput";
+const _DDGO = "DeleteDeploymentGroupOutput";
+const _DDNEE = "DeploymentDoesNotExistException";
+const _DGAEE = "DeploymentGroupAlreadyExistsException";
+const _DGDNEE = "DeploymentGroupDoesNotExistException";
+const _DGHAT = "DeleteGitHubAccountToken";
+const _DGHATI = "DeleteGitHubAccountTokenInput";
+const _DGHATO = "DeleteGitHubAccountTokenOutput";
+const _DGI = "DeploymentGroupInfo";
+const _DGIL = "DeploymentGroupInfoList";
+const _DGLEE = "DeploymentGroupLimitExceededException";
+const _DGNRE = "DeploymentGroupNameRequiredException";
+const _DI = "DeploymentInfo";
+const _DIL = "DeploymentsInfoList";
+const _DINIRSE = "DeploymentIsNotInReadyStateException";
+const _DIRE = "DeploymentIdRequiredException";
+const _DLEE = "DeploymentLimitExceededException";
+const _DNSE = "DeploymentNotStartedException";
+const _DO = "DeploymentOverview";
+const _DOPI = "DeregisterOnPremisesInstance";
+const _DOPII = "DeregisterOnPremisesInstanceInput";
+const _DRBEI = "DeleteResourcesByExternalId";
+const _DRBEII = "DeleteResourcesByExternalIdInput";
+const _DRBEIO = "DeleteResourcesByExternalIdOutput";
+const _DRO = "DeploymentReadyOption";
+const _DS = "DeploymentStyle";
+const _DT = "DeploymentTarget";
+const _DTDNEE = "DeploymentTargetDoesNotExistException";
+const _DTIRE = "DeploymentTargetIdRequiredException";
+const _DTL = "DeploymentTargetList";
+const _DTLE = "DescriptionTooLongException";
+const _DTLSEE = "DeploymentTargetListSizeExceededException";
+const _ECSS = "ECSService";
+const _ECSSL = "ECSServiceList";
+const _ECSSMLEE = "ECSServiceMappingLimitExceededException";
+const _ECST = "ECSTarget";
+const _ECSTS = "ECSTaskSet";
+const _ECSTSL = "ECSTaskSetList";
+const _ECTF = "EC2TagFilter";
+const _ECTFL = "EC2TagFilterList";
+const _ECTS = "EC2TagSet";
+const _ECTSL = "EC2TagSetList";
+const _EI = "ErrorInformation";
+const _ELBI = "ELBInfo";
+const _ELBIL = "ELBInfoList";
+const _F = "Failed";
+const _GA = "GetApplication";
+const _GAI = "GetApplicationInput";
+const _GAO = "GetApplicationOutput";
+const _GAR = "GetApplicationRevision";
+const _GARI = "GetApplicationRevisionInput";
+const _GARO = "GetApplicationRevisionOutput";
+const _GD = "GetDeployment";
+const _GDC = "GetDeploymentConfig";
+const _GDCI = "GetDeploymentConfigInput";
+const _GDCO = "GetDeploymentConfigOutput";
+const _GDG = "GetDeploymentGroup";
+const _GDGI = "GetDeploymentGroupInput";
+const _GDGO = "GetDeploymentGroupOutput";
+const _GDI = "GetDeploymentInput";
+const _GDII = "GetDeploymentInstanceInput";
+const _GDIO = "GetDeploymentInstanceOutput";
+const _GDIe = "GetDeploymentInstance";
+const _GDO = "GetDeploymentOutput";
+const _GDT = "GetDeploymentTarget";
+const _GDTI = "GetDeploymentTargetInput";
+const _GDTO = "GetDeploymentTargetOutput";
+const _GFPO = "GreenFleetProvisioningOption";
+const _GHATDNEE = "GitHubAccountTokenDoesNotExistException";
+const _GHATNRE = "GitHubAccountTokenNameRequiredException";
+const _GHL = "GitHubLocation";
+const _GOPI = "GetOnPremisesInstance";
+const _GOPII = "GetOnPremisesInstanceInput";
+const _GOPIO = "GetOnPremisesInstanceOutput";
+const _GRI = "GenericRevisionInfo";
+const _IACE = "InvalidAlarmConfigException";
+const _IAE = "InvalidArnException";
+const _IANE = "InvalidApplicationNameException";
+const _IARCE = "InvalidAutoRollbackConfigException";
+const _IARE = "IamArnRequiredException";
+const _IASGE = "InvalidAutoScalingGroupException";
+const _IBGDCE = "InvalidBlueGreenDeploymentConfigurationException";
+const _IBNFE = "InvalidBucketNameFilterException";
+const _ICPE = "InvalidComputePlatformException";
+const _IDCNE = "InvalidDeploymentConfigNameException";
+const _IDGNE = "InvalidDeploymentGroupNameException";
+const _IDIE = "InvalidDeploymentIdException";
+const _IDITE = "InvalidDeploymentInstanceTypeException";
+const _IDNEE = "InstanceDoesNotExistException";
+const _IDSE = "InvalidDeploymentStatusException";
+const _IDSEn = "InvalidDeploymentStyleException";
+const _IDSFE = "InvalidDeployedStateFilterException";
+const _IDTIE = "InvalidDeploymentTargetIdException";
+const _IDWTE = "InvalidDeploymentWaitTypeException";
+const _IECSSE = "InvalidECSServiceException";
+const _IECTCE = "InvalidEC2TagCombinationException";
+const _IECTE = "InvalidEC2TagException";
+const _IEIE = "InvalidExternalIdException";
+const _IFEBE = "InvalidFileExistsBehaviorException";
+const _IGHATE = "InvalidGitHubAccountTokenException";
+const _IGHATNE = "InvalidGitHubAccountTokenNameException";
+const _II = "InstanceInfo";
+const _IIASFVE = "InvalidIgnoreApplicationStopFailuresValueException";
+const _IIE = "InvalidInputException";
+const _IIL = "InstanceInfoList";
+const _IINE = "InvalidInstanceNameException";
+const _IIRE = "InstanceIdRequiredException";
+const _IISAE = "InvalidIamSessionArnException";
+const _IISE = "InvalidInstanceStatusException";
+const _IITE = "InvalidInstanceTypeException";
+const _IIUAE = "InvalidIamUserArnException";
+const _IKPFE = "InvalidKeyPrefixFilterException";
+const _ILBIE = "InvalidLoadBalancerInfoException";
+const _ILEE = "InstanceLimitExceededException";
+const _ILEHEIE = "InvalidLifecycleEventHookExecutionIdException";
+const _ILEHESE = "InvalidLifecycleEventHookExecutionStatusException";
+const _IMHHVE = "InvalidMinimumHealthyHostValueException";
+const _INARE = "InstanceNameAlreadyRegisteredException";
+const _INRE = "InstanceNameRequiredException";
+const _INREn = "InstanceNotRegisteredException";
+const _INTE = "InvalidNextTokenException";
+const _IOE = "InvalidOperationException";
+const _IOPTCE = "InvalidOnPremisesTagCombinationException";
+const _IP = "InProgress";
+const _IRE = "InvalidRevisionException";
+const _IREn = "InvalidRoleException";
+const _IRSE = "InvalidRegistrationStatusException";
+const _IS = "InstanceSummary";
+const _ISAARE = "IamSessionArnAlreadyRegisteredException";
+const _ISBE = "InvalidSortByException";
+const _ISL = "InstanceSummaryList";
+const _ISOE = "InvalidSortOrderException";
+const _IT = "InstanceTarget";
+const _ITCE = "InvalidTriggerConfigException";
+const _ITE = "InvalidTagException";
+const _ITFE = "InvalidTagFilterException";
+const _ITFNE = "InvalidTargetFilterNameException";
+const _ITGPE = "InvalidTargetGroupPairException";
+const _ITIE = "InvalidTargetInstancesException";
+const _ITRCE = "InvalidTrafficRoutingConfigurationException";
+const _ITRE = "InvalidTimeRangeException";
+const _ITTAE = "InvalidTagsToAddException";
+const _IUAARE = "IamUserArnAlreadyRegisteredException";
+const _IUARE = "IamUserArnRequiredException";
+const _IUOIOVE = "InvalidUpdateOutdatedInstancesOnlyValueException";
+const _IZDCE = "InvalidZonalDeploymentConfigurationException";
+const _K = "Key";
+const _LA = "ListApplications";
+const _LAI = "ListApplicationsInput";
+const _LAO = "ListApplicationsOutput";
+const _LAR = "ListApplicationRevisions";
+const _LARI = "ListApplicationRevisionsInput";
+const _LARO = "ListApplicationRevisionsOutput";
+const _LBI = "LoadBalancerInfo";
+const _LD = "ListDeployments";
+const _LDC = "ListDeploymentConfigs";
+const _LDCI = "ListDeploymentConfigsInput";
+const _LDCO = "ListDeploymentConfigsOutput";
+const _LDG = "ListDeploymentGroups";
+const _LDGI = "ListDeploymentGroupsInput";
+const _LDGO = "ListDeploymentGroupsOutput";
+const _LDI = "LastDeploymentInfo";
+const _LDII = "ListDeploymentInstancesInput";
+const _LDIO = "ListDeploymentInstancesOutput";
+const _LDIi = "ListDeploymentsInput";
+const _LDIis = "ListDeploymentInstances";
+const _LDO = "ListDeploymentsOutput";
+const _LDT = "ListDeploymentTargets";
+const _LDTI = "ListDeploymentTargetsInput";
+const _LDTO = "ListDeploymentTargetsOutput";
+const _LE = "LifecycleEvent";
+const _LEACE = "LifecycleEventAlreadyCompletedException";
+const _LEL = "LifecycleEventList";
+const _LFI = "LambdaFunctionInfo";
+const _LGHATN = "ListGitHubAccountTokenNames";
+const _LGHATNI = "ListGitHubAccountTokenNamesInput";
+const _LGHATNO = "ListGitHubAccountTokenNamesOutput";
+const _LHLEE = "LifecycleHookLimitExceededException";
+const _LOPI = "ListOnPremisesInstances";
+const _LOPII = "ListOnPremisesInstancesInput";
+const _LOPIO = "ListOnPremisesInstancesOutput";
+const _LT = "LambdaTarget";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _MHH = "MinimumHealthyHosts";
+const _MHHPZ = "MinimumHealthyHostsPerZone";
+const _MIAPE = "MultipleIamArnsProvidedException";
+const _NT = "NextToken";
+const _ONSE = "OperationNotSupportedException";
+const _OPTS = "OnPremisesTagSet";
+const _OPTSL = "OnPremisesTagSetList";
+const _P = "Pending";
+const _PLEHES = "PutLifecycleEventHookExecutionStatus";
+const _PLEHESI = "PutLifecycleEventHookExecutionStatusInput";
+const _PLEHESO = "PutLifecycleEventHookExecutionStatusOutput";
+const _R = "Ready";
+const _RA = "ResourceArn";
+const _RAR = "RegisterApplicationRevision";
+const _RARE = "ResourceArnRequiredException";
+const _RARI = "RegisterApplicationRevisionInput";
+const _RD = "RelatedDeployments";
+const _RDNEE = "RevisionDoesNotExistException";
+const _RI = "RevisionInfo";
+const _RIL = "RevisionInfoList";
+const _RIo = "RollbackInfo";
+const _RL = "RevisionLocation";
+const _RLL = "RevisionLocationList";
+const _ROPI = "RegisterOnPremisesInstance";
+const _ROPII = "RegisterOnPremisesInstanceInput";
+const _RRE = "RevisionRequiredException";
+const _RREo = "RoleRequiredException";
+const _RS = "RawString";
+const _RTFOPI = "RemoveTagsFromOnPremisesInstances";
+const _RTFOPII = "RemoveTagsFromOnPremisesInstancesInput";
+const _RVE = "ResourceValidationException";
+const _S = "Succeeded";
+const _SD = "StopDeployment";
+const _SDI = "StopDeploymentInput";
+const _SDO = "StopDeploymentOutput";
+const _SL = "S3Location";
+const _SWTFIT = "SkipWaitTimeForInstanceTermination";
+const _SWTFITI = "SkipWaitTimeForInstanceTerminationInput";
+const _Sk = "Skipped";
+const _T = "Type";
+const _TBC = "TimeBasedCanary";
+const _TBL = "TimeBasedLinear";
+const _TC = "TriggerConfig";
+const _TCL = "TriggerConfigList";
+const _TE = "ThrottlingException";
+const _TF = "TargetFilters";
+const _TFL = "TagFilterList";
+const _TFa = "TagFilter";
+const _TGI = "TargetGroupInfo";
+const _TGIL = "TargetGroupInfoList";
+const _TGPI = "TargetGroupPairInfo";
+const _TGPIL = "TargetGroupPairInfoList";
+const _TI = "TargetInstances";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TLEE = "TagLimitExceededException";
+const _TR = "TimeRange";
+const _TRC = "TrafficRoutingConfig";
+const _TRE = "TagRequiredException";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _TRa = "TagResource";
+const _TRr = "TrafficRoute";
+const _TSLLEE = "TagSetListLimitExceededException";
+const _TTLEE = "TriggerTargetsLimitExceededException";
+const _Ta = "Tags";
+const _Tag = "Tag";
+const _UA = "UpdateApplication";
+const _UAFDTE = "UnsupportedActionForDeploymentTypeException";
+const _UAI = "UpdateApplicationInput";
+const _UDG = "UpdateDeploymentGroup";
+const _UDGI = "UpdateDeploymentGroupInput";
+const _UDGO = "UpdateDeploymentGroupOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _V = "Value";
+const _ZC = "ZonalConfig";
+const _a = "alarms";
+const _aC = "alarmConfiguration";
+const _aDSI = "additionalDeploymentStatusInfo";
+const _aI = "applicationId";
+const _aIp = "applicationsInfo";
+const _aN = "applicationName";
+const _aNp = "applicationNames";
+const _aOT = "actionOnTimeout";
+const _aRC = "autoRollbackConfiguration";
+const _aRE = "autoRollbackEnabled";
+const _aSC = "appSpecContent";
+const _aSG = "autoScalingGroups";
+const _aUOIDI = "autoUpdateOutdatedInstancesDeploymentIds";
+const _aUOIRDI = "autoUpdateOutdatedInstancesRootDeploymentId";
+const _ac = "action";
+const _ap = "application";
+const _app = "applications";
+const _b = "bucket";
+const _bGDC = "blueGreenDeploymentConfiguration";
+const _bT = "bundleType";
+const _c = "client";
+const _cDGN = "currentDeploymentGroupName";
+const _cFT = "cloudFormationTarget";
+const _cI = "commitId";
+const _cIa = "canaryInterval";
+const _cN = "clusterName";
+const _cP = "computePlatform";
+const _cPa = "canaryPercentage";
+const _cT = "createTime";
+const _cTR = "createTimeRange";
+const _cTo = "completeTime";
+const _cV = "currentVersion";
+const _co = "content";
+const _cod = "code";
+const _cr = "creator";
+const _d = "description";
+const _dC = "desiredCount";
+const _dCI = "deploymentConfigId";
+const _dCIe = "deploymentConfigInfo";
+const _dCL = "deploymentConfigsList";
+const _dCN = "deploymentConfigName";
+const _dG = "deploymentGroups";
+const _dGI = "deploymentGroupsInfo";
+const _dGIe = "deploymentGroupId";
+const _dGIep = "deploymentGroupInfo";
+const _dGN = "deploymentGroupNames";
+const _dGNe = "deploymentGroupName";
+const _dI = "deploymentId";
+const _dIe = "deploymentIds";
+const _dIep = "deploymentsInfo";
+const _dIepl = "deploymentInfo";
+const _dO = "deploymentOverview";
+const _dOe = "deploymentOption";
+const _dRO = "deploymentReadyOption";
+const _dS = "deploymentStyle";
+const _dSM = "deploymentStatusMessages";
+const _dT = "deploymentTargets";
+const _dTT = "deploymentTargetType";
+const _dTe = "deploymentType";
+const _dTep = "deploymentTarget";
+const _dTer = "deregisterTime";
+const _dWT = "deploymentWaitType";
+const _de = "deployed";
+const _dep = "deployments";
+const _di = "diagnostics";
+const _e = "error";
+const _eC = "errorCode";
+const _eI = "externalId";
+const _eIL = "elbInfoList";
+const _eIr = "errorInformation";
+const _eM = "errorMessage";
+const _eS = "ecsServices";
+const _eT = "ecsTarget";
+const _eTF = "ec2TagFilters";
+const _eTS = "ec2TagSet";
+const _eTSL = "ec2TagSetList";
+const _eTa = "eTag";
+const _eTn = "endTime";
+const _en = "enabled";
+const _end = "end";
+const _ev = "events";
+const _fA = "functionAlias";
+const _fEB = "fileExistsBehavior";
+const _fN = "functionName";
+const _fUT = "firstUsedTime";
+const _fZMDIS = "firstZoneMonitorDurationInSeconds";
+const _gFPO = "greenFleetProvisioningOption";
+const _gHAN = "gitHubAccountName";
+const _gHL = "gitHubLocation";
+const _gRI = "genericRevisionInfo";
+const _h = "hook";
+const _hNCU = "hooksNotCleanedUp";
+const _i = "identifer";
+const _iA = "instanceArn";
+const _iASF = "ignoreApplicationStopFailures";
+const _iI = "instanceIds";
+const _iIn = "instanceInfos";
+const _iIns = "instanceId";
+const _iInst = "instanceInfo";
+const _iL = "instanceLabel";
+const _iLn = "instancesList";
+const _iN = "instanceNames";
+const _iNn = "instanceName";
+const _iOS = "includeOnlyStatuses";
+const _iPAF = "ignorePollAlarmFailure";
+const _iS = "instancesSummary";
+const _iSA = "iamSessionArn";
+const _iSF = "instanceStatusFilter";
+const _iSn = "instanceSummary";
+const _iT = "instanceTarget";
+const _iTF = "instanceTypeFilter";
+const _iTWTS = "instanceTerminationWaitTimeStarted";
+const _iTn = "instanceType";
+const _iUA = "iamUserArn";
+const _k = "key";
+const _lA = "listenerArns";
+const _lAD = "lastAttemptedDeployment";
+const _lBI = "loadBalancerInfo";
+const _lE = "lifecycleEvents";
+const _lEHEI = "lifecycleEventHookExecutionId";
+const _lEN = "lifecycleEventName";
+const _lFI = "lambdaFunctionInfo";
+const _lI = "linearInterval";
+const _lP = "linearPercentage";
+const _lSD = "lastSuccessfulDeployment";
+const _lT = "lambdaTarget";
+const _lTGH = "linkedToGitHub";
+const _lTo = "logTail";
+const _lUA = "lastUpdatedAt";
+const _lUT = "lastUsedTime";
+const _m = "message";
+const _mDIS = "monitorDurationInSeconds";
+const _mHH = "minimumHealthyHosts";
+const _mHHPZ = "minimumHealthyHostsPerZone";
+const _n = "name";
+const _nAN = "newApplicationName";
+const _nDGN = "newDeploymentGroupName";
+const _nT = "nextToken";
+const _oAC = "overrideAlarmConfiguration";
+const _oIS = "outdatedInstancesStrategy";
+const _oPITF = "onPremisesInstanceTagFilters";
+const _oPTS = "onPremisesTagSet";
+const _oPTSL = "onPremisesTagSetList";
+const _pC = "pendingCount";
+const _pR = "previousRevision";
+const _pTR = "prodTrafficRoute";
+const _r = "revisions";
+const _rC = "runningCount";
+const _rD = "relatedDeployments";
+const _rDI = "rollbackDeploymentId";
+const _rI = "rollbackInfo";
+const _rIe = "revisionInfo";
+const _rL = "revisionLocation";
+const _rM = "rollbackMessage";
+const _rS = "registrationStatus";
+const _rT = "resourceType";
+const _rTDI = "rollbackTriggeringDeploymentId";
+const _rTe = "registerTime";
+const _rTev = "revisionType";
+const _re = "revision";
+const _rep = "repository";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.codedeploy";
+const _sB = "sortBy";
+const _sBu = "s3Bucket";
+const _sKP = "s3KeyPrefix";
+const _sL = "s3Location";
+const _sM = "statusMessage";
+const _sN = "scriptName";
+const _sNe = "serviceName";
+const _sO = "sortOrder";
+const _sRA = "serviceRoleArn";
+const _sT = "startTime";
+const _sh = "sha256";
+const _st = "status";
+const _sta = "start";
+const _str = "string";
+const _t = "tags";
+const _tA = "targetArn";
+const _tBC = "timeBasedCanary";
+const _tBIODS = "terminateBlueInstancesOnDeploymentSuccess";
+const _tBL = "timeBasedLinear";
+const _tC = "triggerConfigurations";
+const _tE = "triggerEvents";
+const _tF = "targetFilters";
+const _tFa = "tagFilters";
+const _tG = "targetGroup";
+const _tGIL = "targetGroupInfoList";
+const _tGPIL = "targetGroupPairInfoList";
+const _tGa = "targetGroups";
+const _tH = "terminationHook";
+const _tHE = "terminationHookEnabled";
+const _tI = "targetIds";
+const _tIa = "targetId";
+const _tIar = "targetInstances";
+const _tN = "tokenName";
+const _tNL = "tokenNameList";
+const _tNr = "triggerName";
+const _tR = "targetRevision";
+const _tRC = "trafficRoutingConfig";
+const _tSI = "taskSetsInfo";
+const _tSL = "taskSetLabel";
+const _tTA = "triggerTargetArn";
+const _tTR = "testTrafficRoute";
+const _tV = "targetVersion";
+const _tVW = "targetVersionWeight";
+const _tW = "trafficWeight";
+const _tWTIM = "terminationWaitTimeInMinutes";
+const _ty = "type";
+const _uOIO = "updateOutdatedInstancesOnly";
+const _v = "value";
+const _ve = "version";
+const _wTIM = "waitTimeInMinutes";
+const _zC = "zonalConfig";
+const n0 = "com.amazonaws.codedeploy";
+const _s_registry = TypeRegistry.for(_s);
+var CodeDeployServiceException$ = [-3, _s, "CodeDeployServiceException", 0, [], []];
+_s_registry.registerError(CodeDeployServiceException$, CodeDeployServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var AlarmsLimitExceededException$ = [-3, n0, _ALEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(AlarmsLimitExceededException$, AlarmsLimitExceededException);
+var ApplicationAlreadyExistsException$ = [-3, n0, _AAEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ApplicationAlreadyExistsException$, ApplicationAlreadyExistsException);
+var ApplicationDoesNotExistException$ = [-3, n0, _ADNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ApplicationDoesNotExistException$, ApplicationDoesNotExistException);
+var ApplicationLimitExceededException$ = [-3, n0, _ALEEp,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ApplicationLimitExceededException$, ApplicationLimitExceededException);
+var ApplicationNameRequiredException$ = [-3, n0, _ANRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ApplicationNameRequiredException$, ApplicationNameRequiredException);
+var ArnNotSupportedException$ = [-3, n0, _ANSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ArnNotSupportedException$, ArnNotSupportedException);
+var BatchLimitExceededException$ = [-3, n0, _BLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(BatchLimitExceededException$, BatchLimitExceededException);
+var BucketNameFilterRequiredException$ = [-3, n0, _BNFRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(BucketNameFilterRequiredException$, BucketNameFilterRequiredException);
+var DeploymentAlreadyCompletedException$ = [-3, n0, _DACE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentAlreadyCompletedException$, DeploymentAlreadyCompletedException);
+var DeploymentConfigAlreadyExistsException$ = [-3, n0, _DCAEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentConfigAlreadyExistsException$, DeploymentConfigAlreadyExistsException);
+var DeploymentConfigDoesNotExistException$ = [-3, n0, _DCDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentConfigDoesNotExistException$, DeploymentConfigDoesNotExistException);
+var DeploymentConfigInUseException$ = [-3, n0, _DCIUE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentConfigInUseException$, DeploymentConfigInUseException);
+var DeploymentConfigLimitExceededException$ = [-3, n0, _DCLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentConfigLimitExceededException$, DeploymentConfigLimitExceededException);
+var DeploymentConfigNameRequiredException$ = [-3, n0, _DCNRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentConfigNameRequiredException$, DeploymentConfigNameRequiredException);
+var DeploymentDoesNotExistException$ = [-3, n0, _DDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentDoesNotExistException$, DeploymentDoesNotExistException);
+var DeploymentGroupAlreadyExistsException$ = [-3, n0, _DGAEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentGroupAlreadyExistsException$, DeploymentGroupAlreadyExistsException);
+var DeploymentGroupDoesNotExistException$ = [-3, n0, _DGDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentGroupDoesNotExistException$, DeploymentGroupDoesNotExistException);
+var DeploymentGroupLimitExceededException$ = [-3, n0, _DGLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentGroupLimitExceededException$, DeploymentGroupLimitExceededException);
+var DeploymentGroupNameRequiredException$ = [-3, n0, _DGNRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentGroupNameRequiredException$, DeploymentGroupNameRequiredException);
+var DeploymentIdRequiredException$ = [-3, n0, _DIRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentIdRequiredException$, DeploymentIdRequiredException);
+var DeploymentIsNotInReadyStateException$ = [-3, n0, _DINIRSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentIsNotInReadyStateException$, DeploymentIsNotInReadyStateException);
+var DeploymentLimitExceededException$ = [-3, n0, _DLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentLimitExceededException$, DeploymentLimitExceededException);
+var DeploymentNotStartedException$ = [-3, n0, _DNSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentNotStartedException$, DeploymentNotStartedException);
+var DeploymentTargetDoesNotExistException$ = [-3, n0, _DTDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentTargetDoesNotExistException$, DeploymentTargetDoesNotExistException);
+var DeploymentTargetIdRequiredException$ = [-3, n0, _DTIRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentTargetIdRequiredException$, DeploymentTargetIdRequiredException);
+var DeploymentTargetListSizeExceededException$ = [-3, n0, _DTLSEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DeploymentTargetListSizeExceededException$, DeploymentTargetListSizeExceededException);
+var DescriptionTooLongException$ = [-3, n0, _DTLE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DescriptionTooLongException$, DescriptionTooLongException);
+var ECSServiceMappingLimitExceededException$ = [-3, n0, _ECSSMLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ECSServiceMappingLimitExceededException$, ECSServiceMappingLimitExceededException);
+var GitHubAccountTokenDoesNotExistException$ = [-3, n0, _GHATDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(GitHubAccountTokenDoesNotExistException$, GitHubAccountTokenDoesNotExistException);
+var GitHubAccountTokenNameRequiredException$ = [-3, n0, _GHATNRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(GitHubAccountTokenNameRequiredException$, GitHubAccountTokenNameRequiredException);
+var IamArnRequiredException$ = [-3, n0, _IARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IamArnRequiredException$, IamArnRequiredException);
+var IamSessionArnAlreadyRegisteredException$ = [-3, n0, _ISAARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IamSessionArnAlreadyRegisteredException$, IamSessionArnAlreadyRegisteredException);
+var IamUserArnAlreadyRegisteredException$ = [-3, n0, _IUAARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IamUserArnAlreadyRegisteredException$, IamUserArnAlreadyRegisteredException);
+var IamUserArnRequiredException$ = [-3, n0, _IUARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(IamUserArnRequiredException$, IamUserArnRequiredException);
+var InstanceDoesNotExistException$ = [-3, n0, _IDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceDoesNotExistException$, InstanceDoesNotExistException);
+var InstanceIdRequiredException$ = [-3, n0, _IIRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceIdRequiredException$, InstanceIdRequiredException);
+var InstanceLimitExceededException$ = [-3, n0, _ILEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceLimitExceededException$, InstanceLimitExceededException);
+var InstanceNameAlreadyRegisteredException$ = [-3, n0, _INARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceNameAlreadyRegisteredException$, InstanceNameAlreadyRegisteredException);
+var InstanceNameRequiredException$ = [-3, n0, _INRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceNameRequiredException$, InstanceNameRequiredException);
+var InstanceNotRegisteredException$ = [-3, n0, _INREn,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InstanceNotRegisteredException$, InstanceNotRegisteredException);
+var InvalidAlarmConfigException$ = [-3, n0, _IACE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidAlarmConfigException$, InvalidAlarmConfigException);
+var InvalidApplicationNameException$ = [-3, n0, _IANE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidApplicationNameException$, InvalidApplicationNameException);
+var InvalidArnException$ = [-3, n0, _IAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidArnException$, InvalidArnException);
+var InvalidAutoRollbackConfigException$ = [-3, n0, _IARCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidAutoRollbackConfigException$, InvalidAutoRollbackConfigException);
+var InvalidAutoScalingGroupException$ = [-3, n0, _IASGE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidAutoScalingGroupException$, InvalidAutoScalingGroupException);
+var InvalidBlueGreenDeploymentConfigurationException$ = [-3, n0, _IBGDCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidBlueGreenDeploymentConfigurationException$, InvalidBlueGreenDeploymentConfigurationException);
+var InvalidBucketNameFilterException$ = [-3, n0, _IBNFE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidBucketNameFilterException$, InvalidBucketNameFilterException);
+var InvalidComputePlatformException$ = [-3, n0, _ICPE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidComputePlatformException$, InvalidComputePlatformException);
+var InvalidDeployedStateFilterException$ = [-3, n0, _IDSFE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeployedStateFilterException$, InvalidDeployedStateFilterException);
+var InvalidDeploymentConfigNameException$ = [-3, n0, _IDCNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentConfigNameException$, InvalidDeploymentConfigNameException);
+var InvalidDeploymentGroupNameException$ = [-3, n0, _IDGNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentGroupNameException$, InvalidDeploymentGroupNameException);
+var InvalidDeploymentIdException$ = [-3, n0, _IDIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentIdException$, InvalidDeploymentIdException);
+var InvalidDeploymentInstanceTypeException$ = [-3, n0, _IDITE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentInstanceTypeException$, InvalidDeploymentInstanceTypeException);
+var InvalidDeploymentStatusException$ = [-3, n0, _IDSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentStatusException$, InvalidDeploymentStatusException);
+var InvalidDeploymentStyleException$ = [-3, n0, _IDSEn,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentStyleException$, InvalidDeploymentStyleException);
+var InvalidDeploymentTargetIdException$ = [-3, n0, _IDTIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentTargetIdException$, InvalidDeploymentTargetIdException);
+var InvalidDeploymentWaitTypeException$ = [-3, n0, _IDWTE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDeploymentWaitTypeException$, InvalidDeploymentWaitTypeException);
+var InvalidEC2TagCombinationException$ = [-3, n0, _IECTCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidEC2TagCombinationException$, InvalidEC2TagCombinationException);
+var InvalidEC2TagException$ = [-3, n0, _IECTE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidEC2TagException$, InvalidEC2TagException);
+var InvalidECSServiceException$ = [-3, n0, _IECSSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidECSServiceException$, InvalidECSServiceException);
+var InvalidExternalIdException$ = [-3, n0, _IEIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidExternalIdException$, InvalidExternalIdException);
+var InvalidFileExistsBehaviorException$ = [-3, n0, _IFEBE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidFileExistsBehaviorException$, InvalidFileExistsBehaviorException);
+var InvalidGitHubAccountTokenException$ = [-3, n0, _IGHATE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidGitHubAccountTokenException$, InvalidGitHubAccountTokenException);
+var InvalidGitHubAccountTokenNameException$ = [-3, n0, _IGHATNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidGitHubAccountTokenNameException$, InvalidGitHubAccountTokenNameException);
+var InvalidIamSessionArnException$ = [-3, n0, _IISAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidIamSessionArnException$, InvalidIamSessionArnException);
+var InvalidIamUserArnException$ = [-3, n0, _IIUAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidIamUserArnException$, InvalidIamUserArnException);
+var InvalidIgnoreApplicationStopFailuresValueException$ = [-3, n0, _IIASFVE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidIgnoreApplicationStopFailuresValueException$, InvalidIgnoreApplicationStopFailuresValueException);
+var InvalidInputException$ = [-3, n0, _IIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidInputException$, InvalidInputException);
+var InvalidInstanceNameException$ = [-3, n0, _IINE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidInstanceNameException$, InvalidInstanceNameException);
+var InvalidInstanceStatusException$ = [-3, n0, _IISE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidInstanceStatusException$, InvalidInstanceStatusException);
+var InvalidInstanceTypeException$ = [-3, n0, _IITE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidInstanceTypeException$, InvalidInstanceTypeException);
+var InvalidKeyPrefixFilterException$ = [-3, n0, _IKPFE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidKeyPrefixFilterException$, InvalidKeyPrefixFilterException);
+var InvalidLifecycleEventHookExecutionIdException$ = [-3, n0, _ILEHEIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidLifecycleEventHookExecutionIdException$, InvalidLifecycleEventHookExecutionIdException);
+var InvalidLifecycleEventHookExecutionStatusException$ = [-3, n0, _ILEHESE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidLifecycleEventHookExecutionStatusException$, InvalidLifecycleEventHookExecutionStatusException);
+var InvalidLoadBalancerInfoException$ = [-3, n0, _ILBIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidLoadBalancerInfoException$, InvalidLoadBalancerInfoException);
+var InvalidMinimumHealthyHostValueException$ = [-3, n0, _IMHHVE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidMinimumHealthyHostValueException$, InvalidMinimumHealthyHostValueException);
+var InvalidNextTokenException$ = [-3, n0, _INTE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidNextTokenException$, InvalidNextTokenException);
+var InvalidOnPremisesTagCombinationException$ = [-3, n0, _IOPTCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidOnPremisesTagCombinationException$, InvalidOnPremisesTagCombinationException);
+var InvalidOperationException$ = [-3, n0, _IOE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidOperationException$, InvalidOperationException);
+var InvalidRegistrationStatusException$ = [-3, n0, _IRSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidRegistrationStatusException$, InvalidRegistrationStatusException);
+var InvalidRevisionException$ = [-3, n0, _IRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidRevisionException$, InvalidRevisionException);
+var InvalidRoleException$ = [-3, n0, _IREn,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidRoleException$, InvalidRoleException);
+var InvalidSortByException$ = [-3, n0, _ISBE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSortByException$, InvalidSortByException);
+var InvalidSortOrderException$ = [-3, n0, _ISOE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSortOrderException$, InvalidSortOrderException);
+var InvalidTagException$ = [-3, n0, _ITE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTagException$, InvalidTagException);
+var InvalidTagFilterException$ = [-3, n0, _ITFE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTagFilterException$, InvalidTagFilterException);
+var InvalidTagsToAddException$ = [-3, n0, _ITTAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTagsToAddException$, InvalidTagsToAddException);
+var InvalidTargetFilterNameException$ = [-3, n0, _ITFNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTargetFilterNameException$, InvalidTargetFilterNameException);
+var InvalidTargetGroupPairException$ = [-3, n0, _ITGPE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTargetGroupPairException$, InvalidTargetGroupPairException);
+var InvalidTargetInstancesException$ = [-3, n0, _ITIE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTargetInstancesException$, InvalidTargetInstancesException);
+var InvalidTimeRangeException$ = [-3, n0, _ITRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTimeRangeException$, InvalidTimeRangeException);
+var InvalidTrafficRoutingConfigurationException$ = [-3, n0, _ITRCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTrafficRoutingConfigurationException$, InvalidTrafficRoutingConfigurationException);
+var InvalidTriggerConfigException$ = [-3, n0, _ITCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTriggerConfigException$, InvalidTriggerConfigException);
+var InvalidUpdateOutdatedInstancesOnlyValueException$ = [-3, n0, _IUOIOVE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidUpdateOutdatedInstancesOnlyValueException$, InvalidUpdateOutdatedInstancesOnlyValueException);
+var InvalidZonalDeploymentConfigurationException$ = [-3, n0, _IZDCE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidZonalDeploymentConfigurationException$, InvalidZonalDeploymentConfigurationException);
+var LifecycleEventAlreadyCompletedException$ = [-3, n0, _LEACE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LifecycleEventAlreadyCompletedException$, LifecycleEventAlreadyCompletedException);
+var LifecycleHookLimitExceededException$ = [-3, n0, _LHLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LifecycleHookLimitExceededException$, LifecycleHookLimitExceededException);
+var MultipleIamArnsProvidedException$ = [-3, n0, _MIAPE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MultipleIamArnsProvidedException$, MultipleIamArnsProvidedException);
+var OperationNotSupportedException$ = [-3, n0, _ONSE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(OperationNotSupportedException$, OperationNotSupportedException);
+var ResourceArnRequiredException$ = [-3, n0, _RARE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceArnRequiredException$, ResourceArnRequiredException);
+var ResourceValidationException$ = [-3, n0, _RVE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceValidationException$, ResourceValidationException);
+var RevisionDoesNotExistException$ = [-3, n0, _RDNEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(RevisionDoesNotExistException$, RevisionDoesNotExistException);
+var RevisionRequiredException$ = [-3, n0, _RRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(RevisionRequiredException$, RevisionRequiredException);
+var RoleRequiredException$ = [-3, n0, _RREo,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(RoleRequiredException$, RoleRequiredException);
+var TagLimitExceededException$ = [-3, n0, _TLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagLimitExceededException$, TagLimitExceededException);
+var TagRequiredException$ = [-3, n0, _TRE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagRequiredException$, TagRequiredException);
+var TagSetListLimitExceededException$ = [-3, n0, _TSLLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagSetListLimitExceededException$, TagSetListLimitExceededException);
+var ThrottlingException$ = [-3, n0, _TE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ThrottlingException$, ThrottlingException);
+var TriggerTargetsLimitExceededException$ = [-3, n0, _TTLEE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TriggerTargetsLimitExceededException$, TriggerTargetsLimitExceededException);
+var UnsupportedActionForDeploymentTypeException$ = [-3, n0, _UAFDTE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UnsupportedActionForDeploymentTypeException$, UnsupportedActionForDeploymentTypeException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var AddTagsToOnPremisesInstancesInput$ = [3, n0, _ATTOPII,
+    0,
+    [_t, _iN],
+    [() => TagList, 64 | 0], 2
+];
+var Alarm$ = [3, n0, _A,
+    0,
+    [_n],
+    [0]
+];
+var AlarmConfiguration$ = [3, n0, _AC,
+    0,
+    [_en, _iPAF, _a],
+    [2, 2, () => AlarmList]
+];
+var ApplicationInfo$ = [3, n0, _AI,
+    0,
+    [_aI, _aN, _cT, _lTGH, _gHAN, _cP],
+    [0, 0, 4, 2, 0, 0]
+];
+var AppSpecContent$ = [3, n0, _ASC,
+    0,
+    [_co, _sh],
+    [0, 0]
+];
+var AutoRollbackConfiguration$ = [3, n0, _ARC,
+    0,
+    [_en, _ev],
+    [2, 64 | 0]
+];
+var AutoScalingGroup$ = [3, n0, _ASG,
+    0,
+    [_n, _h, _tH],
+    [0, 0, 0]
+];
+var BatchGetApplicationRevisionsInput$ = [3, n0, _BGARI,
+    0,
+    [_aN, _r],
+    [0, () => RevisionLocationList], 2
+];
+var BatchGetApplicationRevisionsOutput$ = [3, n0, _BGARO,
+    0,
+    [_aN, _eM, _r],
+    [0, 0, () => RevisionInfoList]
+];
+var BatchGetApplicationsInput$ = [3, n0, _BGAI,
+    0,
+    [_aNp],
+    [64 | 0], 1
+];
+var BatchGetApplicationsOutput$ = [3, n0, _BGAO,
+    0,
+    [_aIp],
+    [() => ApplicationsInfoList]
+];
+var BatchGetDeploymentGroupsInput$ = [3, n0, _BGDGI,
+    0,
+    [_aN, _dGN],
+    [0, 64 | 0], 2
+];
+var BatchGetDeploymentGroupsOutput$ = [3, n0, _BGDGO,
+    0,
+    [_dGI, _eM],
+    [() => DeploymentGroupInfoList, 0]
+];
+var BatchGetDeploymentInstancesInput$ = [3, n0, _BGDII,
+    0,
+    [_dI, _iI],
+    [0, 64 | 0], 2
+];
+var BatchGetDeploymentInstancesOutput$ = [3, n0, _BGDIO,
+    0,
+    [_iS, _eM],
+    [() => InstanceSummaryList, 0]
+];
+var BatchGetDeploymentsInput$ = [3, n0, _BGDI,
+    0,
+    [_dIe],
+    [64 | 0], 1
+];
+var BatchGetDeploymentsOutput$ = [3, n0, _BGDO,
+    0,
+    [_dIep],
+    [() => DeploymentsInfoList]
+];
+var BatchGetDeploymentTargetsInput$ = [3, n0, _BGDTI,
+    0,
+    [_dI, _tI],
+    [0, 64 | 0], 2
+];
+var BatchGetDeploymentTargetsOutput$ = [3, n0, _BGDTO,
+    0,
+    [_dT],
+    [() => DeploymentTargetList]
+];
+var BatchGetOnPremisesInstancesInput$ = [3, n0, _BGOPII,
+    0,
+    [_iN],
+    [64 | 0], 1
+];
+var BatchGetOnPremisesInstancesOutput$ = [3, n0, _BGOPIO,
+    0,
+    [_iIn],
+    [() => InstanceInfoList]
+];
+var BlueGreenDeploymentConfiguration$ = [3, n0, _BGDC,
+    0,
+    [_tBIODS, _dRO, _gFPO],
+    [() => BlueInstanceTerminationOption$, () => DeploymentReadyOption$, () => GreenFleetProvisioningOption$]
+];
+var BlueInstanceTerminationOption$ = [3, n0, _BITO,
+    0,
+    [_ac, _tWTIM],
+    [0, 1]
+];
+var CloudFormationTarget$ = [3, n0, _CFT,
+    0,
+    [_dI, _tIa, _lUA, _lE, _st, _rT, _tVW],
+    [0, 0, 4, () => LifecycleEventList, 0, 0, 1]
+];
+var ContinueDeploymentInput$ = [3, n0, _CDI,
+    0,
+    [_dI, _dWT],
+    [0, 0]
+];
+var CreateApplicationInput$ = [3, n0, _CAI,
+    0,
+    [_aN, _cP, _t],
+    [0, 0, () => TagList], 1
+];
+var CreateApplicationOutput$ = [3, n0, _CAO,
+    0,
+    [_aI],
+    [0]
+];
+var CreateDeploymentConfigInput$ = [3, n0, _CDCI,
+    0,
+    [_dCN, _mHH, _tRC, _cP, _zC],
+    [0, () => MinimumHealthyHosts$, () => TrafficRoutingConfig$, 0, () => ZonalConfig$], 1
+];
+var CreateDeploymentConfigOutput$ = [3, n0, _CDCO,
+    0,
+    [_dCI],
+    [0]
+];
+var CreateDeploymentGroupInput$ = [3, n0, _CDGI,
+    0,
+    [_aN, _dGNe, _sRA, _dCN, _eTF, _oPITF, _aSG, _tC, _aC, _aRC, _oIS, _dS, _bGDC, _lBI, _eTS, _eS, _oPTS, _t, _tHE],
+    [0, 0, 0, 0, () => EC2TagFilterList, () => TagFilterList, 64 | 0, () => TriggerConfigList, () => AlarmConfiguration$, () => AutoRollbackConfiguration$, 0, () => DeploymentStyle$, () => BlueGreenDeploymentConfiguration$, () => LoadBalancerInfo$, () => EC2TagSet$, () => ECSServiceList, () => OnPremisesTagSet$, () => TagList, 2], 3
+];
+var CreateDeploymentGroupOutput$ = [3, n0, _CDGO,
+    0,
+    [_dGIe],
+    [0]
+];
+var CreateDeploymentInput$ = [3, n0, _CDIr,
+    0,
+    [_aN, _dGNe, _re, _dCN, _d, _iASF, _tIar, _aRC, _uOIO, _fEB, _oAC],
+    [0, 0, () => RevisionLocation$, 0, 0, 2, () => TargetInstances$, () => AutoRollbackConfiguration$, 2, 0, () => AlarmConfiguration$], 1
+];
+var CreateDeploymentOutput$ = [3, n0, _CDO,
+    0,
+    [_dI],
+    [0]
+];
+var DeleteApplicationInput$ = [3, n0, _DAI,
+    0,
+    [_aN],
+    [0], 1
+];
+var DeleteDeploymentConfigInput$ = [3, n0, _DDCI,
+    0,
+    [_dCN],
+    [0], 1
+];
+var DeleteDeploymentGroupInput$ = [3, n0, _DDGI,
+    0,
+    [_aN, _dGNe],
+    [0, 0], 2
+];
+var DeleteDeploymentGroupOutput$ = [3, n0, _DDGO,
+    0,
+    [_hNCU],
+    [() => AutoScalingGroupList]
+];
+var DeleteGitHubAccountTokenInput$ = [3, n0, _DGHATI,
+    0,
+    [_tN],
+    [0]
+];
+var DeleteGitHubAccountTokenOutput$ = [3, n0, _DGHATO,
+    0,
+    [_tN],
+    [0]
+];
+var DeleteResourcesByExternalIdInput$ = [3, n0, _DRBEII,
+    0,
+    [_eI],
+    [0]
+];
+var DeleteResourcesByExternalIdOutput$ = [3, n0, _DRBEIO,
+    0,
+    [],
+    []
+];
+var DeploymentConfigInfo$ = [3, n0, _DCI,
+    0,
+    [_dCI, _dCN, _mHH, _cT, _cP, _tRC, _zC],
+    [0, 0, () => MinimumHealthyHosts$, 4, 0, () => TrafficRoutingConfig$, () => ZonalConfig$]
+];
+var DeploymentGroupInfo$ = [3, n0, _DGI,
+    0,
+    [_aN, _dGIe, _dGNe, _dCN, _eTF, _oPITF, _aSG, _sRA, _tR, _tC, _aC, _aRC, _dS, _oIS, _bGDC, _lBI, _lSD, _lAD, _eTS, _oPTS, _cP, _eS, _tHE],
+    [0, 0, 0, 0, () => EC2TagFilterList, () => TagFilterList, () => AutoScalingGroupList, 0, () => RevisionLocation$, () => TriggerConfigList, () => AlarmConfiguration$, () => AutoRollbackConfiguration$, () => DeploymentStyle$, 0, () => BlueGreenDeploymentConfiguration$, () => LoadBalancerInfo$, () => LastDeploymentInfo$, () => LastDeploymentInfo$, () => EC2TagSet$, () => OnPremisesTagSet$, 0, () => ECSServiceList, 2]
+];
+var DeploymentInfo$ = [3, n0, _DI,
+    0,
+    [_aN, _dGNe, _dCN, _dI, _pR, _re, _st, _eIr, _cT, _sT, _cTo, _dO, _d, _cr, _iASF, _aRC, _uOIO, _rI, _dS, _tIar, _iTWTS, _bGDC, _lBI, _aDSI, _fEB, _dSM, _cP, _eI, _rD, _oAC],
+    [0, 0, 0, 0, () => RevisionLocation$, () => RevisionLocation$, 0, () => ErrorInformation$, 4, 4, 4, () => DeploymentOverview$, 0, 0, 2, () => AutoRollbackConfiguration$, 2, () => RollbackInfo$, () => DeploymentStyle$, () => TargetInstances$, 2, () => BlueGreenDeploymentConfiguration$, () => LoadBalancerInfo$, 0, 0, 64 | 0, 0, 0, () => RelatedDeployments$, () => AlarmConfiguration$]
+];
+var DeploymentOverview$ = [3, n0, _DO,
+    0,
+    [_P, _IP, _S, _F, _Sk, _R],
+    [1, 1, 1, 1, 1, 1]
+];
+var DeploymentReadyOption$ = [3, n0, _DRO,
+    0,
+    [_aOT, _wTIM],
+    [0, 1]
+];
+var DeploymentStyle$ = [3, n0, _DS,
+    0,
+    [_dTe, _dOe],
+    [0, 0]
+];
+var DeploymentTarget$ = [3, n0, _DT,
+    0,
+    [_dTT, _iT, _lT, _eT, _cFT],
+    [0, () => InstanceTarget$, () => LambdaTarget$, () => ECSTarget$, () => CloudFormationTarget$]
+];
+var DeregisterOnPremisesInstanceInput$ = [3, n0, _DOPII,
+    0,
+    [_iNn],
+    [0], 1
+];
+var Diagnostics$ = [3, n0, _D,
+    0,
+    [_eC, _sN, _m, _lTo],
+    [0, 0, 0, 0]
+];
+var EC2TagFilter$ = [3, n0, _ECTF,
+    0,
+    [_K, _V, _T],
+    [0, 0, 0]
+];
+var EC2TagSet$ = [3, n0, _ECTS,
+    0,
+    [_eTSL],
+    [() => EC2TagSetList]
+];
+var ECSService$ = [3, n0, _ECSS,
+    0,
+    [_sNe, _cN],
+    [0, 0]
+];
+var ECSTarget$ = [3, n0, _ECST,
+    0,
+    [_dI, _tIa, _tA, _lUA, _lE, _st, _tSI],
+    [0, 0, 0, 4, () => LifecycleEventList, 0, () => ECSTaskSetList]
+];
+var ECSTaskSet$ = [3, n0, _ECSTS,
+    0,
+    [_i, _dC, _pC, _rC, _st, _tW, _tG, _tSL],
+    [0, 1, 1, 1, 0, 1, () => TargetGroupInfo$, 0]
+];
+var ELBInfo$ = [3, n0, _ELBI,
+    0,
+    [_n],
+    [0]
+];
+var ErrorInformation$ = [3, n0, _EI,
+    0,
+    [_cod, _m],
+    [0, 0]
+];
+var GenericRevisionInfo$ = [3, n0, _GRI,
+    0,
+    [_d, _dG, _fUT, _lUT, _rTe],
+    [0, 64 | 0, 4, 4, 4]
+];
+var GetApplicationInput$ = [3, n0, _GAI,
+    0,
+    [_aN],
+    [0], 1
+];
+var GetApplicationOutput$ = [3, n0, _GAO,
+    0,
+    [_ap],
+    [() => ApplicationInfo$]
+];
+var GetApplicationRevisionInput$ = [3, n0, _GARI,
+    0,
+    [_aN, _re],
+    [0, () => RevisionLocation$], 2
+];
+var GetApplicationRevisionOutput$ = [3, n0, _GARO,
+    0,
+    [_aN, _re, _rIe],
+    [0, () => RevisionLocation$, () => GenericRevisionInfo$]
+];
+var GetDeploymentConfigInput$ = [3, n0, _GDCI,
+    0,
+    [_dCN],
+    [0], 1
+];
+var GetDeploymentConfigOutput$ = [3, n0, _GDCO,
+    0,
+    [_dCIe],
+    [() => DeploymentConfigInfo$]
+];
+var GetDeploymentGroupInput$ = [3, n0, _GDGI,
+    0,
+    [_aN, _dGNe],
+    [0, 0], 2
+];
+var GetDeploymentGroupOutput$ = [3, n0, _GDGO,
+    0,
+    [_dGIep],
+    [() => DeploymentGroupInfo$]
+];
+var GetDeploymentInput$ = [3, n0, _GDI,
+    0,
+    [_dI],
+    [0], 1
+];
+var GetDeploymentInstanceInput$ = [3, n0, _GDII,
+    0,
+    [_dI, _iIns],
+    [0, 0], 2
+];
+var GetDeploymentInstanceOutput$ = [3, n0, _GDIO,
+    0,
+    [_iSn],
+    [() => InstanceSummary$]
+];
+var GetDeploymentOutput$ = [3, n0, _GDO,
+    0,
+    [_dIepl],
+    [() => DeploymentInfo$]
+];
+var GetDeploymentTargetInput$ = [3, n0, _GDTI,
+    0,
+    [_dI, _tIa],
+    [0, 0], 2
+];
+var GetDeploymentTargetOutput$ = [3, n0, _GDTO,
+    0,
+    [_dTep],
+    [() => DeploymentTarget$]
+];
+var GetOnPremisesInstanceInput$ = [3, n0, _GOPII,
+    0,
+    [_iNn],
+    [0], 1
+];
+var GetOnPremisesInstanceOutput$ = [3, n0, _GOPIO,
+    0,
+    [_iInst],
+    [() => InstanceInfo$]
+];
+var GitHubLocation$ = [3, n0, _GHL,
+    0,
+    [_rep, _cI],
+    [0, 0]
+];
+var GreenFleetProvisioningOption$ = [3, n0, _GFPO,
+    0,
+    [_ac],
+    [0]
+];
+var InstanceInfo$ = [3, n0, _II,
+    0,
+    [_iNn, _iSA, _iUA, _iA, _rTe, _dTer, _t],
+    [0, 0, 0, 0, 4, 4, () => TagList]
+];
+var InstanceSummary$ = [3, n0, _IS,
+    0,
+    [_dI, _iIns, _st, _lUA, _lE, _iTn],
+    [0, 0, 0, 4, () => LifecycleEventList, 0]
+];
+var InstanceTarget$ = [3, n0, _IT,
+    0,
+    [_dI, _tIa, _tA, _st, _lUA, _lE, _iL],
+    [0, 0, 0, 0, 4, () => LifecycleEventList, 0]
+];
+var LambdaFunctionInfo$ = [3, n0, _LFI,
+    0,
+    [_fN, _fA, _cV, _tV, _tVW],
+    [0, 0, 0, 0, 1]
+];
+var LambdaTarget$ = [3, n0, _LT,
+    0,
+    [_dI, _tIa, _tA, _st, _lUA, _lE, _lFI],
+    [0, 0, 0, 0, 4, () => LifecycleEventList, () => LambdaFunctionInfo$]
+];
+var LastDeploymentInfo$ = [3, n0, _LDI,
+    0,
+    [_dI, _st, _eTn, _cT],
+    [0, 0, 4, 4]
+];
+var LifecycleEvent$ = [3, n0, _LE,
+    0,
+    [_lEN, _di, _sT, _eTn, _st],
+    [0, () => Diagnostics$, 4, 4, 0]
+];
+var ListApplicationRevisionsInput$ = [3, n0, _LARI,
+    0,
+    [_aN, _sB, _sO, _sBu, _sKP, _de, _nT],
+    [0, 0, 0, 0, 0, 0, 0], 1
+];
+var ListApplicationRevisionsOutput$ = [3, n0, _LARO,
+    0,
+    [_r, _nT],
+    [() => RevisionLocationList, 0]
+];
+var ListApplicationsInput$ = [3, n0, _LAI,
+    0,
+    [_nT],
+    [0]
+];
+var ListApplicationsOutput$ = [3, n0, _LAO,
+    0,
+    [_app, _nT],
+    [64 | 0, 0]
+];
+var ListDeploymentConfigsInput$ = [3, n0, _LDCI,
+    0,
+    [_nT],
+    [0]
+];
+var ListDeploymentConfigsOutput$ = [3, n0, _LDCO,
+    0,
+    [_dCL, _nT],
+    [64 | 0, 0]
+];
+var ListDeploymentGroupsInput$ = [3, n0, _LDGI,
+    0,
+    [_aN, _nT],
+    [0, 0], 1
+];
+var ListDeploymentGroupsOutput$ = [3, n0, _LDGO,
+    0,
+    [_aN, _dG, _nT],
+    [0, 64 | 0, 0]
+];
+var ListDeploymentInstancesInput$ = [3, n0, _LDII,
+    0,
+    [_dI, _nT, _iSF, _iTF],
+    [0, 0, 64 | 0, 64 | 0], 1
+];
+var ListDeploymentInstancesOutput$ = [3, n0, _LDIO,
+    0,
+    [_iLn, _nT],
+    [64 | 0, 0]
+];
+var ListDeploymentsInput$ = [3, n0, _LDIi,
+    0,
+    [_aN, _dGNe, _eI, _iOS, _cTR, _nT],
+    [0, 0, 0, 64 | 0, () => TimeRange$, 0]
+];
+var ListDeploymentsOutput$ = [3, n0, _LDO,
+    0,
+    [_dep, _nT],
+    [64 | 0, 0]
+];
+var ListDeploymentTargetsInput$ = [3, n0, _LDTI,
+    0,
+    [_dI, _nT, _tF],
+    [0, 0, [2, n0, _TF, 0, 0, 64 | 0]], 1
+];
+var ListDeploymentTargetsOutput$ = [3, n0, _LDTO,
+    0,
+    [_tI, _nT],
+    [64 | 0, 0]
+];
+var ListGitHubAccountTokenNamesInput$ = [3, n0, _LGHATNI,
+    0,
+    [_nT],
+    [0]
+];
+var ListGitHubAccountTokenNamesOutput$ = [3, n0, _LGHATNO,
+    0,
+    [_tNL, _nT],
+    [64 | 0, 0]
+];
+var ListOnPremisesInstancesInput$ = [3, n0, _LOPII,
+    0,
+    [_rS, _tFa, _nT],
+    [0, () => TagFilterList, 0]
+];
+var ListOnPremisesInstancesOutput$ = [3, n0, _LOPIO,
+    0,
+    [_iN, _nT],
+    [64 | 0, 0]
+];
+var ListTagsForResourceInput$ = [3, n0, _LTFRI,
+    0,
+    [_RA, _NT],
+    [0, 0], 1
+];
+var ListTagsForResourceOutput$ = [3, n0, _LTFRO,
+    0,
+    [_Ta, _NT],
+    [() => TagList, 0]
+];
+var LoadBalancerInfo$ = [3, n0, _LBI,
+    0,
+    [_eIL, _tGIL, _tGPIL],
+    [() => ELBInfoList, () => TargetGroupInfoList, () => TargetGroupPairInfoList]
+];
+var MinimumHealthyHosts$ = [3, n0, _MHH,
+    0,
+    [_ty, _v],
+    [0, 1]
+];
+var MinimumHealthyHostsPerZone$ = [3, n0, _MHHPZ,
+    0,
+    [_ty, _v],
+    [0, 1]
+];
+var OnPremisesTagSet$ = [3, n0, _OPTS,
+    0,
+    [_oPTSL],
+    [() => OnPremisesTagSetList]
+];
+var PutLifecycleEventHookExecutionStatusInput$ = [3, n0, _PLEHESI,
+    0,
+    [_dI, _lEHEI, _st],
+    [0, 0, 0]
+];
+var PutLifecycleEventHookExecutionStatusOutput$ = [3, n0, _PLEHESO,
+    0,
+    [_lEHEI],
+    [0]
+];
+var RawString$ = [3, n0, _RS,
+    0,
+    [_co, _sh],
+    [0, 0]
+];
+var RegisterApplicationRevisionInput$ = [3, n0, _RARI,
+    0,
+    [_aN, _re, _d],
+    [0, () => RevisionLocation$, 0], 2
+];
+var RegisterOnPremisesInstanceInput$ = [3, n0, _ROPII,
+    0,
+    [_iNn, _iSA, _iUA],
+    [0, 0, 0], 1
+];
+var RelatedDeployments$ = [3, n0, _RD,
+    0,
+    [_aUOIRDI, _aUOIDI],
+    [0, 64 | 0]
+];
+var RemoveTagsFromOnPremisesInstancesInput$ = [3, n0, _RTFOPII,
+    0,
+    [_t, _iN],
+    [() => TagList, 64 | 0], 2
+];
+var RevisionInfo$ = [3, n0, _RI,
+    0,
+    [_rL, _gRI],
+    [() => RevisionLocation$, () => GenericRevisionInfo$]
+];
+var RevisionLocation$ = [3, n0, _RL,
+    0,
+    [_rTev, _sL, _gHL, _str, _aSC],
+    [0, () => S3Location$, () => GitHubLocation$, () => RawString$, () => AppSpecContent$]
+];
+var RollbackInfo$ = [3, n0, _RIo,
+    0,
+    [_rDI, _rTDI, _rM],
+    [0, 0, 0]
+];
+var S3Location$ = [3, n0, _SL,
+    0,
+    [_b, _k, _bT, _ve, _eTa],
+    [0, 0, 0, 0, 0]
+];
+var SkipWaitTimeForInstanceTerminationInput$ = [3, n0, _SWTFITI,
+    0,
+    [_dI],
+    [0]
+];
+var StopDeploymentInput$ = [3, n0, _SDI,
+    0,
+    [_dI, _aRE],
+    [0, 2], 1
+];
+var StopDeploymentOutput$ = [3, n0, _SDO,
+    0,
+    [_st, _sM],
+    [0, 0]
+];
+var Tag$ = [3, n0, _Tag,
+    0,
+    [_K, _V],
+    [0, 0]
+];
+var TagFilter$ = [3, n0, _TFa,
+    0,
+    [_K, _V, _T],
+    [0, 0, 0]
+];
+var TagResourceInput$ = [3, n0, _TRI,
+    0,
+    [_RA, _Ta],
+    [0, () => TagList], 2
+];
+var TagResourceOutput$ = [3, n0, _TRO,
+    0,
+    [],
+    []
+];
+var TargetGroupInfo$ = [3, n0, _TGI,
+    0,
+    [_n],
+    [0]
+];
+var TargetGroupPairInfo$ = [3, n0, _TGPI,
+    0,
+    [_tGa, _pTR, _tTR],
+    [() => TargetGroupInfoList, () => TrafficRoute$, () => TrafficRoute$]
+];
+var TargetInstances$ = [3, n0, _TI,
+    0,
+    [_tFa, _aSG, _eTS],
+    [() => EC2TagFilterList, 64 | 0, () => EC2TagSet$]
+];
+var TimeBasedCanary$ = [3, n0, _TBC,
+    0,
+    [_cPa, _cIa],
+    [1, 1]
+];
+var TimeBasedLinear$ = [3, n0, _TBL,
+    0,
+    [_lP, _lI],
+    [1, 1]
+];
+var TimeRange$ = [3, n0, _TR,
+    0,
+    [_sta, _end],
+    [4, 4]
+];
+var TrafficRoute$ = [3, n0, _TRr,
+    0,
+    [_lA],
+    [64 | 0]
+];
+var TrafficRoutingConfig$ = [3, n0, _TRC,
+    0,
+    [_ty, _tBC, _tBL],
+    [0, () => TimeBasedCanary$, () => TimeBasedLinear$]
+];
+var TriggerConfig$ = [3, n0, _TC,
+    0,
+    [_tNr, _tTA, _tE],
+    [0, 0, 64 | 0]
+];
+var UntagResourceInput$ = [3, n0, _URI,
+    0,
+    [_RA, _TK],
+    [0, 64 | 0], 2
+];
+var UntagResourceOutput$ = [3, n0, _URO,
+    0,
+    [],
+    []
+];
+var UpdateApplicationInput$ = [3, n0, _UAI,
+    0,
+    [_aN, _nAN],
+    [0, 0]
+];
+var UpdateDeploymentGroupInput$ = [3, n0, _UDGI,
+    0,
+    [_aN, _cDGN, _nDGN, _dCN, _eTF, _oPITF, _aSG, _sRA, _tC, _aC, _aRC, _oIS, _dS, _bGDC, _lBI, _eTS, _eS, _oPTS, _tHE],
+    [0, 0, 0, 0, () => EC2TagFilterList, () => TagFilterList, 64 | 0, 0, () => TriggerConfigList, () => AlarmConfiguration$, () => AutoRollbackConfiguration$, 0, () => DeploymentStyle$, () => BlueGreenDeploymentConfiguration$, () => LoadBalancerInfo$, () => EC2TagSet$, () => ECSServiceList, () => OnPremisesTagSet$, 2], 2
+];
+var UpdateDeploymentGroupOutput$ = [3, n0, _UDGO,
+    0,
+    [_hNCU],
+    [() => AutoScalingGroupList]
+];
+var ZonalConfig$ = [3, n0, _ZC,
+    0,
+    [_fZMDIS, _mDIS, _mHHPZ],
+    [1, 1, () => MinimumHealthyHostsPerZone$]
+];
+var __Unit = "unit";
+var AlarmList = [1, n0, _AL,
+    0, () => Alarm$
+];
+var ApplicationsInfoList = [1, n0, _AIL,
+    0, () => ApplicationInfo$
+];
+var AutoScalingGroupList = [1, n0, _ASGL,
+    0, () => AutoScalingGroup$
+];
+var DeploymentGroupInfoList = [1, n0, _DGIL,
+    0, () => DeploymentGroupInfo$
+];
+var DeploymentsInfoList = [1, n0, _DIL,
+    0, () => DeploymentInfo$
+];
+var DeploymentTargetList = [1, n0, _DTL,
+    0, () => DeploymentTarget$
+];
+var EC2TagFilterList = [1, n0, _ECTFL,
+    0, () => EC2TagFilter$
+];
+var EC2TagSetList = [1, n0, _ECTSL,
+    0, () => EC2TagFilterList
+];
+var ECSServiceList = [1, n0, _ECSSL,
+    0, () => ECSService$
+];
+var ECSTaskSetList = [1, n0, _ECSTSL,
+    0, () => ECSTaskSet$
+];
+var ELBInfoList = [1, n0, _ELBIL,
+    0, () => ELBInfo$
+];
+var InstanceInfoList = [1, n0, _IIL,
+    0, () => InstanceInfo$
+];
+var InstanceSummaryList = [1, n0, _ISL,
+    0, () => InstanceSummary$
+];
+var LifecycleEventList = [1, n0, _LEL,
+    0, () => LifecycleEvent$
+];
+var OnPremisesTagSetList = [1, n0, _OPTSL,
+    0, () => TagFilterList
+];
+var RevisionInfoList = [1, n0, _RIL,
+    0, () => RevisionInfo$
+];
+var RevisionLocationList = [1, n0, _RLL,
+    0, () => RevisionLocation$
+];
+var TagFilterList = [1, n0, _TFL,
+    0, () => TagFilter$
+];
+var TagList = [1, n0, _TL,
+    0, () => Tag$
+];
+var TargetGroupInfoList = [1, n0, _TGIL,
+    0, () => TargetGroupInfo$
+];
+var TargetGroupPairInfoList = [1, n0, _TGPIL,
+    0, () => TargetGroupPairInfo$
+];
+var TriggerConfigList = [1, n0, _TCL,
+    0, () => TriggerConfig$
+];
+var AddTagsToOnPremisesInstances$ = [9, n0, _ATTOPI,
+    0, () => AddTagsToOnPremisesInstancesInput$, () => __Unit
+];
+var BatchGetApplicationRevisions$ = [9, n0, _BGAR,
+    0, () => BatchGetApplicationRevisionsInput$, () => BatchGetApplicationRevisionsOutput$
+];
+var BatchGetApplications$ = [9, n0, _BGA,
+    0, () => BatchGetApplicationsInput$, () => BatchGetApplicationsOutput$
+];
+var BatchGetDeploymentGroups$ = [9, n0, _BGDG,
+    0, () => BatchGetDeploymentGroupsInput$, () => BatchGetDeploymentGroupsOutput$
+];
+var BatchGetDeploymentInstances$ = [9, n0, _BGDIa,
+    0, () => BatchGetDeploymentInstancesInput$, () => BatchGetDeploymentInstancesOutput$
+];
+var BatchGetDeployments$ = [9, n0, _BGD,
+    0, () => BatchGetDeploymentsInput$, () => BatchGetDeploymentsOutput$
+];
+var BatchGetDeploymentTargets$ = [9, n0, _BGDT,
+    0, () => BatchGetDeploymentTargetsInput$, () => BatchGetDeploymentTargetsOutput$
+];
+var BatchGetOnPremisesInstances$ = [9, n0, _BGOPI,
+    0, () => BatchGetOnPremisesInstancesInput$, () => BatchGetOnPremisesInstancesOutput$
+];
+var ContinueDeployment$ = [9, n0, _CD,
+    0, () => ContinueDeploymentInput$, () => __Unit
+];
+var CreateApplication$ = [9, n0, _CA,
+    0, () => CreateApplicationInput$, () => CreateApplicationOutput$
+];
+var CreateDeployment$ = [9, n0, _CDr,
+    0, () => CreateDeploymentInput$, () => CreateDeploymentOutput$
+];
+var CreateDeploymentConfig$ = [9, n0, _CDC,
+    0, () => CreateDeploymentConfigInput$, () => CreateDeploymentConfigOutput$
+];
+var CreateDeploymentGroup$ = [9, n0, _CDG,
+    0, () => CreateDeploymentGroupInput$, () => CreateDeploymentGroupOutput$
+];
+var DeleteApplication$ = [9, n0, _DA,
+    0, () => DeleteApplicationInput$, () => __Unit
+];
+var DeleteDeploymentConfig$ = [9, n0, _DDC,
+    0, () => DeleteDeploymentConfigInput$, () => __Unit
+];
+var DeleteDeploymentGroup$ = [9, n0, _DDG,
+    0, () => DeleteDeploymentGroupInput$, () => DeleteDeploymentGroupOutput$
+];
+var DeleteGitHubAccountToken$ = [9, n0, _DGHAT,
+    0, () => DeleteGitHubAccountTokenInput$, () => DeleteGitHubAccountTokenOutput$
+];
+var DeleteResourcesByExternalId$ = [9, n0, _DRBEI,
+    0, () => DeleteResourcesByExternalIdInput$, () => DeleteResourcesByExternalIdOutput$
+];
+var DeregisterOnPremisesInstance$ = [9, n0, _DOPI,
+    0, () => DeregisterOnPremisesInstanceInput$, () => __Unit
+];
+var GetApplication$ = [9, n0, _GA,
+    0, () => GetApplicationInput$, () => GetApplicationOutput$
+];
+var GetApplicationRevision$ = [9, n0, _GAR,
+    0, () => GetApplicationRevisionInput$, () => GetApplicationRevisionOutput$
+];
+var GetDeployment$ = [9, n0, _GD,
+    0, () => GetDeploymentInput$, () => GetDeploymentOutput$
+];
+var GetDeploymentConfig$ = [9, n0, _GDC,
+    0, () => GetDeploymentConfigInput$, () => GetDeploymentConfigOutput$
+];
+var GetDeploymentGroup$ = [9, n0, _GDG,
+    0, () => GetDeploymentGroupInput$, () => GetDeploymentGroupOutput$
+];
+var GetDeploymentInstance$ = [9, n0, _GDIe,
+    0, () => GetDeploymentInstanceInput$, () => GetDeploymentInstanceOutput$
+];
+var GetDeploymentTarget$ = [9, n0, _GDT,
+    0, () => GetDeploymentTargetInput$, () => GetDeploymentTargetOutput$
+];
+var GetOnPremisesInstance$ = [9, n0, _GOPI,
+    0, () => GetOnPremisesInstanceInput$, () => GetOnPremisesInstanceOutput$
+];
+var ListApplicationRevisions$ = [9, n0, _LAR,
+    0, () => ListApplicationRevisionsInput$, () => ListApplicationRevisionsOutput$
+];
+var ListApplications$ = [9, n0, _LA,
+    0, () => ListApplicationsInput$, () => ListApplicationsOutput$
+];
+var ListDeploymentConfigs$ = [9, n0, _LDC,
+    0, () => ListDeploymentConfigsInput$, () => ListDeploymentConfigsOutput$
+];
+var ListDeploymentGroups$ = [9, n0, _LDG,
+    0, () => ListDeploymentGroupsInput$, () => ListDeploymentGroupsOutput$
+];
+var ListDeploymentInstances$ = [9, n0, _LDIis,
+    0, () => ListDeploymentInstancesInput$, () => ListDeploymentInstancesOutput$
+];
+var ListDeployments$ = [9, n0, _LD,
+    0, () => ListDeploymentsInput$, () => ListDeploymentsOutput$
+];
+var ListDeploymentTargets$ = [9, n0, _LDT,
+    0, () => ListDeploymentTargetsInput$, () => ListDeploymentTargetsOutput$
+];
+var ListGitHubAccountTokenNames$ = [9, n0, _LGHATN,
+    0, () => ListGitHubAccountTokenNamesInput$, () => ListGitHubAccountTokenNamesOutput$
+];
+var ListOnPremisesInstances$ = [9, n0, _LOPI,
+    0, () => ListOnPremisesInstancesInput$, () => ListOnPremisesInstancesOutput$
+];
+var ListTagsForResource$ = [9, n0, _LTFR,
+    0, () => ListTagsForResourceInput$, () => ListTagsForResourceOutput$
+];
+var PutLifecycleEventHookExecutionStatus$ = [9, n0, _PLEHES,
+    0, () => PutLifecycleEventHookExecutionStatusInput$, () => PutLifecycleEventHookExecutionStatusOutput$
+];
+var RegisterApplicationRevision$ = [9, n0, _RAR,
+    0, () => RegisterApplicationRevisionInput$, () => __Unit
+];
+var RegisterOnPremisesInstance$ = [9, n0, _ROPI,
+    0, () => RegisterOnPremisesInstanceInput$, () => __Unit
+];
+var RemoveTagsFromOnPremisesInstances$ = [9, n0, _RTFOPI,
+    0, () => RemoveTagsFromOnPremisesInstancesInput$, () => __Unit
+];
+var SkipWaitTimeForInstanceTermination$ = [9, n0, _SWTFIT,
+    0, () => SkipWaitTimeForInstanceTerminationInput$, () => __Unit
+];
+var StopDeployment$ = [9, n0, _SD,
+    0, () => StopDeploymentInput$, () => StopDeploymentOutput$
+];
+var TagResource$ = [9, n0, _TRa,
+    0, () => TagResourceInput$, () => TagResourceOutput$
+];
+var UntagResource$ = [9, n0, _UR,
+    0, () => UntagResourceInput$, () => UntagResourceOutput$
+];
+var UpdateApplication$ = [9, n0, _UA,
+    0, () => UpdateApplicationInput$, () => __Unit
+];
+var UpdateDeploymentGroup$ = [9, n0, _UDG,
+    0, () => UpdateDeploymentGroupInput$, () => UpdateDeploymentGroupOutput$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2014-10-06",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultCodeDeployHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsJson1_1Protocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.codedeploy",
+            errorTypeRegistries,
+            xmlNamespace: "http://codedeploy.amazonaws.com/doc/2014-10-06/",
+            version: "2014-10-06",
+            serviceTarget: "CodeDeploy_20141006",
+        },
+        serviceId: config?.serviceId ?? "CodeDeploy",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -1021,89 +4638,499 @@ const StopStatus = {
     SUCCEEDED: "Succeeded",
 };
 
+exports.AddTagsToOnPremisesInstances$ = AddTagsToOnPremisesInstances$;
 exports.AddTagsToOnPremisesInstancesCommand = AddTagsToOnPremisesInstancesCommand;
+exports.AddTagsToOnPremisesInstancesInput$ = AddTagsToOnPremisesInstancesInput$;
+exports.Alarm$ = Alarm$;
+exports.AlarmConfiguration$ = AlarmConfiguration$;
+exports.AlarmsLimitExceededException = AlarmsLimitExceededException;
+exports.AlarmsLimitExceededException$ = AlarmsLimitExceededException$;
+exports.AppSpecContent$ = AppSpecContent$;
+exports.ApplicationAlreadyExistsException = ApplicationAlreadyExistsException;
+exports.ApplicationAlreadyExistsException$ = ApplicationAlreadyExistsException$;
+exports.ApplicationDoesNotExistException = ApplicationDoesNotExistException;
+exports.ApplicationDoesNotExistException$ = ApplicationDoesNotExistException$;
+exports.ApplicationInfo$ = ApplicationInfo$;
+exports.ApplicationLimitExceededException = ApplicationLimitExceededException;
+exports.ApplicationLimitExceededException$ = ApplicationLimitExceededException$;
+exports.ApplicationNameRequiredException = ApplicationNameRequiredException;
+exports.ApplicationNameRequiredException$ = ApplicationNameRequiredException$;
 exports.ApplicationRevisionSortBy = ApplicationRevisionSortBy;
+exports.ArnNotSupportedException = ArnNotSupportedException;
+exports.ArnNotSupportedException$ = ArnNotSupportedException$;
+exports.AutoRollbackConfiguration$ = AutoRollbackConfiguration$;
 exports.AutoRollbackEvent = AutoRollbackEvent;
+exports.AutoScalingGroup$ = AutoScalingGroup$;
+exports.BatchGetApplicationRevisions$ = BatchGetApplicationRevisions$;
 exports.BatchGetApplicationRevisionsCommand = BatchGetApplicationRevisionsCommand;
+exports.BatchGetApplicationRevisionsInput$ = BatchGetApplicationRevisionsInput$;
+exports.BatchGetApplicationRevisionsOutput$ = BatchGetApplicationRevisionsOutput$;
+exports.BatchGetApplications$ = BatchGetApplications$;
 exports.BatchGetApplicationsCommand = BatchGetApplicationsCommand;
+exports.BatchGetApplicationsInput$ = BatchGetApplicationsInput$;
+exports.BatchGetApplicationsOutput$ = BatchGetApplicationsOutput$;
+exports.BatchGetDeploymentGroups$ = BatchGetDeploymentGroups$;
 exports.BatchGetDeploymentGroupsCommand = BatchGetDeploymentGroupsCommand;
+exports.BatchGetDeploymentGroupsInput$ = BatchGetDeploymentGroupsInput$;
+exports.BatchGetDeploymentGroupsOutput$ = BatchGetDeploymentGroupsOutput$;
+exports.BatchGetDeploymentInstances$ = BatchGetDeploymentInstances$;
 exports.BatchGetDeploymentInstancesCommand = BatchGetDeploymentInstancesCommand;
+exports.BatchGetDeploymentInstancesInput$ = BatchGetDeploymentInstancesInput$;
+exports.BatchGetDeploymentInstancesOutput$ = BatchGetDeploymentInstancesOutput$;
+exports.BatchGetDeploymentTargets$ = BatchGetDeploymentTargets$;
 exports.BatchGetDeploymentTargetsCommand = BatchGetDeploymentTargetsCommand;
+exports.BatchGetDeploymentTargetsInput$ = BatchGetDeploymentTargetsInput$;
+exports.BatchGetDeploymentTargetsOutput$ = BatchGetDeploymentTargetsOutput$;
+exports.BatchGetDeployments$ = BatchGetDeployments$;
 exports.BatchGetDeploymentsCommand = BatchGetDeploymentsCommand;
+exports.BatchGetDeploymentsInput$ = BatchGetDeploymentsInput$;
+exports.BatchGetDeploymentsOutput$ = BatchGetDeploymentsOutput$;
+exports.BatchGetOnPremisesInstances$ = BatchGetOnPremisesInstances$;
 exports.BatchGetOnPremisesInstancesCommand = BatchGetOnPremisesInstancesCommand;
+exports.BatchGetOnPremisesInstancesInput$ = BatchGetOnPremisesInstancesInput$;
+exports.BatchGetOnPremisesInstancesOutput$ = BatchGetOnPremisesInstancesOutput$;
+exports.BatchLimitExceededException = BatchLimitExceededException;
+exports.BatchLimitExceededException$ = BatchLimitExceededException$;
+exports.BlueGreenDeploymentConfiguration$ = BlueGreenDeploymentConfiguration$;
+exports.BlueInstanceTerminationOption$ = BlueInstanceTerminationOption$;
+exports.BucketNameFilterRequiredException = BucketNameFilterRequiredException;
+exports.BucketNameFilterRequiredException$ = BucketNameFilterRequiredException$;
 exports.BundleType = BundleType;
+exports.CloudFormationTarget$ = CloudFormationTarget$;
 exports.CodeDeploy = CodeDeploy;
 exports.CodeDeployClient = CodeDeployClient;
+exports.CodeDeployServiceException = CodeDeployServiceException;
+exports.CodeDeployServiceException$ = CodeDeployServiceException$;
 exports.ComputePlatform = ComputePlatform;
+exports.ContinueDeployment$ = ContinueDeployment$;
 exports.ContinueDeploymentCommand = ContinueDeploymentCommand;
+exports.ContinueDeploymentInput$ = ContinueDeploymentInput$;
+exports.CreateApplication$ = CreateApplication$;
 exports.CreateApplicationCommand = CreateApplicationCommand;
+exports.CreateApplicationInput$ = CreateApplicationInput$;
+exports.CreateApplicationOutput$ = CreateApplicationOutput$;
+exports.CreateDeployment$ = CreateDeployment$;
 exports.CreateDeploymentCommand = CreateDeploymentCommand;
+exports.CreateDeploymentConfig$ = CreateDeploymentConfig$;
 exports.CreateDeploymentConfigCommand = CreateDeploymentConfigCommand;
+exports.CreateDeploymentConfigInput$ = CreateDeploymentConfigInput$;
+exports.CreateDeploymentConfigOutput$ = CreateDeploymentConfigOutput$;
+exports.CreateDeploymentGroup$ = CreateDeploymentGroup$;
 exports.CreateDeploymentGroupCommand = CreateDeploymentGroupCommand;
+exports.CreateDeploymentGroupInput$ = CreateDeploymentGroupInput$;
+exports.CreateDeploymentGroupOutput$ = CreateDeploymentGroupOutput$;
+exports.CreateDeploymentInput$ = CreateDeploymentInput$;
+exports.CreateDeploymentOutput$ = CreateDeploymentOutput$;
+exports.DeleteApplication$ = DeleteApplication$;
 exports.DeleteApplicationCommand = DeleteApplicationCommand;
+exports.DeleteApplicationInput$ = DeleteApplicationInput$;
+exports.DeleteDeploymentConfig$ = DeleteDeploymentConfig$;
 exports.DeleteDeploymentConfigCommand = DeleteDeploymentConfigCommand;
+exports.DeleteDeploymentConfigInput$ = DeleteDeploymentConfigInput$;
+exports.DeleteDeploymentGroup$ = DeleteDeploymentGroup$;
 exports.DeleteDeploymentGroupCommand = DeleteDeploymentGroupCommand;
+exports.DeleteDeploymentGroupInput$ = DeleteDeploymentGroupInput$;
+exports.DeleteDeploymentGroupOutput$ = DeleteDeploymentGroupOutput$;
+exports.DeleteGitHubAccountToken$ = DeleteGitHubAccountToken$;
 exports.DeleteGitHubAccountTokenCommand = DeleteGitHubAccountTokenCommand;
+exports.DeleteGitHubAccountTokenInput$ = DeleteGitHubAccountTokenInput$;
+exports.DeleteGitHubAccountTokenOutput$ = DeleteGitHubAccountTokenOutput$;
+exports.DeleteResourcesByExternalId$ = DeleteResourcesByExternalId$;
 exports.DeleteResourcesByExternalIdCommand = DeleteResourcesByExternalIdCommand;
+exports.DeleteResourcesByExternalIdInput$ = DeleteResourcesByExternalIdInput$;
+exports.DeleteResourcesByExternalIdOutput$ = DeleteResourcesByExternalIdOutput$;
+exports.DeploymentAlreadyCompletedException = DeploymentAlreadyCompletedException;
+exports.DeploymentAlreadyCompletedException$ = DeploymentAlreadyCompletedException$;
+exports.DeploymentConfigAlreadyExistsException = DeploymentConfigAlreadyExistsException;
+exports.DeploymentConfigAlreadyExistsException$ = DeploymentConfigAlreadyExistsException$;
+exports.DeploymentConfigDoesNotExistException = DeploymentConfigDoesNotExistException;
+exports.DeploymentConfigDoesNotExistException$ = DeploymentConfigDoesNotExistException$;
+exports.DeploymentConfigInUseException = DeploymentConfigInUseException;
+exports.DeploymentConfigInUseException$ = DeploymentConfigInUseException$;
+exports.DeploymentConfigInfo$ = DeploymentConfigInfo$;
+exports.DeploymentConfigLimitExceededException = DeploymentConfigLimitExceededException;
+exports.DeploymentConfigLimitExceededException$ = DeploymentConfigLimitExceededException$;
+exports.DeploymentConfigNameRequiredException = DeploymentConfigNameRequiredException;
+exports.DeploymentConfigNameRequiredException$ = DeploymentConfigNameRequiredException$;
 exports.DeploymentCreator = DeploymentCreator;
+exports.DeploymentDoesNotExistException = DeploymentDoesNotExistException;
+exports.DeploymentDoesNotExistException$ = DeploymentDoesNotExistException$;
+exports.DeploymentGroupAlreadyExistsException = DeploymentGroupAlreadyExistsException;
+exports.DeploymentGroupAlreadyExistsException$ = DeploymentGroupAlreadyExistsException$;
+exports.DeploymentGroupDoesNotExistException = DeploymentGroupDoesNotExistException;
+exports.DeploymentGroupDoesNotExistException$ = DeploymentGroupDoesNotExistException$;
+exports.DeploymentGroupInfo$ = DeploymentGroupInfo$;
+exports.DeploymentGroupLimitExceededException = DeploymentGroupLimitExceededException;
+exports.DeploymentGroupLimitExceededException$ = DeploymentGroupLimitExceededException$;
+exports.DeploymentGroupNameRequiredException = DeploymentGroupNameRequiredException;
+exports.DeploymentGroupNameRequiredException$ = DeploymentGroupNameRequiredException$;
+exports.DeploymentIdRequiredException = DeploymentIdRequiredException;
+exports.DeploymentIdRequiredException$ = DeploymentIdRequiredException$;
+exports.DeploymentInfo$ = DeploymentInfo$;
+exports.DeploymentIsNotInReadyStateException = DeploymentIsNotInReadyStateException;
+exports.DeploymentIsNotInReadyStateException$ = DeploymentIsNotInReadyStateException$;
+exports.DeploymentLimitExceededException = DeploymentLimitExceededException;
+exports.DeploymentLimitExceededException$ = DeploymentLimitExceededException$;
+exports.DeploymentNotStartedException = DeploymentNotStartedException;
+exports.DeploymentNotStartedException$ = DeploymentNotStartedException$;
 exports.DeploymentOption = DeploymentOption;
+exports.DeploymentOverview$ = DeploymentOverview$;
 exports.DeploymentReadyAction = DeploymentReadyAction;
+exports.DeploymentReadyOption$ = DeploymentReadyOption$;
 exports.DeploymentStatus = DeploymentStatus;
+exports.DeploymentStyle$ = DeploymentStyle$;
+exports.DeploymentTarget$ = DeploymentTarget$;
+exports.DeploymentTargetDoesNotExistException = DeploymentTargetDoesNotExistException;
+exports.DeploymentTargetDoesNotExistException$ = DeploymentTargetDoesNotExistException$;
+exports.DeploymentTargetIdRequiredException = DeploymentTargetIdRequiredException;
+exports.DeploymentTargetIdRequiredException$ = DeploymentTargetIdRequiredException$;
+exports.DeploymentTargetListSizeExceededException = DeploymentTargetListSizeExceededException;
+exports.DeploymentTargetListSizeExceededException$ = DeploymentTargetListSizeExceededException$;
 exports.DeploymentTargetType = DeploymentTargetType;
 exports.DeploymentType = DeploymentType;
 exports.DeploymentWaitType = DeploymentWaitType;
+exports.DeregisterOnPremisesInstance$ = DeregisterOnPremisesInstance$;
 exports.DeregisterOnPremisesInstanceCommand = DeregisterOnPremisesInstanceCommand;
+exports.DeregisterOnPremisesInstanceInput$ = DeregisterOnPremisesInstanceInput$;
+exports.DescriptionTooLongException = DescriptionTooLongException;
+exports.DescriptionTooLongException$ = DescriptionTooLongException$;
+exports.Diagnostics$ = Diagnostics$;
+exports.EC2TagFilter$ = EC2TagFilter$;
 exports.EC2TagFilterType = EC2TagFilterType;
+exports.EC2TagSet$ = EC2TagSet$;
+exports.ECSService$ = ECSService$;
+exports.ECSServiceMappingLimitExceededException = ECSServiceMappingLimitExceededException;
+exports.ECSServiceMappingLimitExceededException$ = ECSServiceMappingLimitExceededException$;
+exports.ECSTarget$ = ECSTarget$;
+exports.ECSTaskSet$ = ECSTaskSet$;
+exports.ELBInfo$ = ELBInfo$;
 exports.ErrorCode = ErrorCode;
+exports.ErrorInformation$ = ErrorInformation$;
 exports.FileExistsBehavior = FileExistsBehavior;
+exports.GenericRevisionInfo$ = GenericRevisionInfo$;
+exports.GetApplication$ = GetApplication$;
 exports.GetApplicationCommand = GetApplicationCommand;
+exports.GetApplicationInput$ = GetApplicationInput$;
+exports.GetApplicationOutput$ = GetApplicationOutput$;
+exports.GetApplicationRevision$ = GetApplicationRevision$;
 exports.GetApplicationRevisionCommand = GetApplicationRevisionCommand;
+exports.GetApplicationRevisionInput$ = GetApplicationRevisionInput$;
+exports.GetApplicationRevisionOutput$ = GetApplicationRevisionOutput$;
+exports.GetDeployment$ = GetDeployment$;
 exports.GetDeploymentCommand = GetDeploymentCommand;
+exports.GetDeploymentConfig$ = GetDeploymentConfig$;
 exports.GetDeploymentConfigCommand = GetDeploymentConfigCommand;
+exports.GetDeploymentConfigInput$ = GetDeploymentConfigInput$;
+exports.GetDeploymentConfigOutput$ = GetDeploymentConfigOutput$;
+exports.GetDeploymentGroup$ = GetDeploymentGroup$;
 exports.GetDeploymentGroupCommand = GetDeploymentGroupCommand;
+exports.GetDeploymentGroupInput$ = GetDeploymentGroupInput$;
+exports.GetDeploymentGroupOutput$ = GetDeploymentGroupOutput$;
+exports.GetDeploymentInput$ = GetDeploymentInput$;
+exports.GetDeploymentInstance$ = GetDeploymentInstance$;
 exports.GetDeploymentInstanceCommand = GetDeploymentInstanceCommand;
+exports.GetDeploymentInstanceInput$ = GetDeploymentInstanceInput$;
+exports.GetDeploymentInstanceOutput$ = GetDeploymentInstanceOutput$;
+exports.GetDeploymentOutput$ = GetDeploymentOutput$;
+exports.GetDeploymentTarget$ = GetDeploymentTarget$;
 exports.GetDeploymentTargetCommand = GetDeploymentTargetCommand;
+exports.GetDeploymentTargetInput$ = GetDeploymentTargetInput$;
+exports.GetDeploymentTargetOutput$ = GetDeploymentTargetOutput$;
+exports.GetOnPremisesInstance$ = GetOnPremisesInstance$;
 exports.GetOnPremisesInstanceCommand = GetOnPremisesInstanceCommand;
+exports.GetOnPremisesInstanceInput$ = GetOnPremisesInstanceInput$;
+exports.GetOnPremisesInstanceOutput$ = GetOnPremisesInstanceOutput$;
+exports.GitHubAccountTokenDoesNotExistException = GitHubAccountTokenDoesNotExistException;
+exports.GitHubAccountTokenDoesNotExistException$ = GitHubAccountTokenDoesNotExistException$;
+exports.GitHubAccountTokenNameRequiredException = GitHubAccountTokenNameRequiredException;
+exports.GitHubAccountTokenNameRequiredException$ = GitHubAccountTokenNameRequiredException$;
+exports.GitHubLocation$ = GitHubLocation$;
 exports.GreenFleetProvisioningAction = GreenFleetProvisioningAction;
+exports.GreenFleetProvisioningOption$ = GreenFleetProvisioningOption$;
+exports.IamArnRequiredException = IamArnRequiredException;
+exports.IamArnRequiredException$ = IamArnRequiredException$;
+exports.IamSessionArnAlreadyRegisteredException = IamSessionArnAlreadyRegisteredException;
+exports.IamSessionArnAlreadyRegisteredException$ = IamSessionArnAlreadyRegisteredException$;
+exports.IamUserArnAlreadyRegisteredException = IamUserArnAlreadyRegisteredException;
+exports.IamUserArnAlreadyRegisteredException$ = IamUserArnAlreadyRegisteredException$;
+exports.IamUserArnRequiredException = IamUserArnRequiredException;
+exports.IamUserArnRequiredException$ = IamUserArnRequiredException$;
 exports.InstanceAction = InstanceAction;
+exports.InstanceDoesNotExistException = InstanceDoesNotExistException;
+exports.InstanceDoesNotExistException$ = InstanceDoesNotExistException$;
+exports.InstanceIdRequiredException = InstanceIdRequiredException;
+exports.InstanceIdRequiredException$ = InstanceIdRequiredException$;
+exports.InstanceInfo$ = InstanceInfo$;
+exports.InstanceLimitExceededException = InstanceLimitExceededException;
+exports.InstanceLimitExceededException$ = InstanceLimitExceededException$;
+exports.InstanceNameAlreadyRegisteredException = InstanceNameAlreadyRegisteredException;
+exports.InstanceNameAlreadyRegisteredException$ = InstanceNameAlreadyRegisteredException$;
+exports.InstanceNameRequiredException = InstanceNameRequiredException;
+exports.InstanceNameRequiredException$ = InstanceNameRequiredException$;
+exports.InstanceNotRegisteredException = InstanceNotRegisteredException;
+exports.InstanceNotRegisteredException$ = InstanceNotRegisteredException$;
 exports.InstanceStatus = InstanceStatus;
+exports.InstanceSummary$ = InstanceSummary$;
+exports.InstanceTarget$ = InstanceTarget$;
+exports.InvalidAlarmConfigException = InvalidAlarmConfigException;
+exports.InvalidAlarmConfigException$ = InvalidAlarmConfigException$;
+exports.InvalidApplicationNameException = InvalidApplicationNameException;
+exports.InvalidApplicationNameException$ = InvalidApplicationNameException$;
+exports.InvalidArnException = InvalidArnException;
+exports.InvalidArnException$ = InvalidArnException$;
+exports.InvalidAutoRollbackConfigException = InvalidAutoRollbackConfigException;
+exports.InvalidAutoRollbackConfigException$ = InvalidAutoRollbackConfigException$;
+exports.InvalidAutoScalingGroupException = InvalidAutoScalingGroupException;
+exports.InvalidAutoScalingGroupException$ = InvalidAutoScalingGroupException$;
+exports.InvalidBlueGreenDeploymentConfigurationException = InvalidBlueGreenDeploymentConfigurationException;
+exports.InvalidBlueGreenDeploymentConfigurationException$ = InvalidBlueGreenDeploymentConfigurationException$;
+exports.InvalidBucketNameFilterException = InvalidBucketNameFilterException;
+exports.InvalidBucketNameFilterException$ = InvalidBucketNameFilterException$;
+exports.InvalidComputePlatformException = InvalidComputePlatformException;
+exports.InvalidComputePlatformException$ = InvalidComputePlatformException$;
+exports.InvalidDeployedStateFilterException = InvalidDeployedStateFilterException;
+exports.InvalidDeployedStateFilterException$ = InvalidDeployedStateFilterException$;
+exports.InvalidDeploymentConfigNameException = InvalidDeploymentConfigNameException;
+exports.InvalidDeploymentConfigNameException$ = InvalidDeploymentConfigNameException$;
+exports.InvalidDeploymentGroupNameException = InvalidDeploymentGroupNameException;
+exports.InvalidDeploymentGroupNameException$ = InvalidDeploymentGroupNameException$;
+exports.InvalidDeploymentIdException = InvalidDeploymentIdException;
+exports.InvalidDeploymentIdException$ = InvalidDeploymentIdException$;
+exports.InvalidDeploymentInstanceTypeException = InvalidDeploymentInstanceTypeException;
+exports.InvalidDeploymentInstanceTypeException$ = InvalidDeploymentInstanceTypeException$;
+exports.InvalidDeploymentStatusException = InvalidDeploymentStatusException;
+exports.InvalidDeploymentStatusException$ = InvalidDeploymentStatusException$;
+exports.InvalidDeploymentStyleException = InvalidDeploymentStyleException;
+exports.InvalidDeploymentStyleException$ = InvalidDeploymentStyleException$;
+exports.InvalidDeploymentTargetIdException = InvalidDeploymentTargetIdException;
+exports.InvalidDeploymentTargetIdException$ = InvalidDeploymentTargetIdException$;
+exports.InvalidDeploymentWaitTypeException = InvalidDeploymentWaitTypeException;
+exports.InvalidDeploymentWaitTypeException$ = InvalidDeploymentWaitTypeException$;
+exports.InvalidEC2TagCombinationException = InvalidEC2TagCombinationException;
+exports.InvalidEC2TagCombinationException$ = InvalidEC2TagCombinationException$;
+exports.InvalidEC2TagException = InvalidEC2TagException;
+exports.InvalidEC2TagException$ = InvalidEC2TagException$;
+exports.InvalidECSServiceException = InvalidECSServiceException;
+exports.InvalidECSServiceException$ = InvalidECSServiceException$;
+exports.InvalidExternalIdException = InvalidExternalIdException;
+exports.InvalidExternalIdException$ = InvalidExternalIdException$;
+exports.InvalidFileExistsBehaviorException = InvalidFileExistsBehaviorException;
+exports.InvalidFileExistsBehaviorException$ = InvalidFileExistsBehaviorException$;
+exports.InvalidGitHubAccountTokenException = InvalidGitHubAccountTokenException;
+exports.InvalidGitHubAccountTokenException$ = InvalidGitHubAccountTokenException$;
+exports.InvalidGitHubAccountTokenNameException = InvalidGitHubAccountTokenNameException;
+exports.InvalidGitHubAccountTokenNameException$ = InvalidGitHubAccountTokenNameException$;
+exports.InvalidIamSessionArnException = InvalidIamSessionArnException;
+exports.InvalidIamSessionArnException$ = InvalidIamSessionArnException$;
+exports.InvalidIamUserArnException = InvalidIamUserArnException;
+exports.InvalidIamUserArnException$ = InvalidIamUserArnException$;
+exports.InvalidIgnoreApplicationStopFailuresValueException = InvalidIgnoreApplicationStopFailuresValueException;
+exports.InvalidIgnoreApplicationStopFailuresValueException$ = InvalidIgnoreApplicationStopFailuresValueException$;
+exports.InvalidInputException = InvalidInputException;
+exports.InvalidInputException$ = InvalidInputException$;
+exports.InvalidInstanceNameException = InvalidInstanceNameException;
+exports.InvalidInstanceNameException$ = InvalidInstanceNameException$;
+exports.InvalidInstanceStatusException = InvalidInstanceStatusException;
+exports.InvalidInstanceStatusException$ = InvalidInstanceStatusException$;
+exports.InvalidInstanceTypeException = InvalidInstanceTypeException;
+exports.InvalidInstanceTypeException$ = InvalidInstanceTypeException$;
+exports.InvalidKeyPrefixFilterException = InvalidKeyPrefixFilterException;
+exports.InvalidKeyPrefixFilterException$ = InvalidKeyPrefixFilterException$;
+exports.InvalidLifecycleEventHookExecutionIdException = InvalidLifecycleEventHookExecutionIdException;
+exports.InvalidLifecycleEventHookExecutionIdException$ = InvalidLifecycleEventHookExecutionIdException$;
+exports.InvalidLifecycleEventHookExecutionStatusException = InvalidLifecycleEventHookExecutionStatusException;
+exports.InvalidLifecycleEventHookExecutionStatusException$ = InvalidLifecycleEventHookExecutionStatusException$;
+exports.InvalidLoadBalancerInfoException = InvalidLoadBalancerInfoException;
+exports.InvalidLoadBalancerInfoException$ = InvalidLoadBalancerInfoException$;
+exports.InvalidMinimumHealthyHostValueException = InvalidMinimumHealthyHostValueException;
+exports.InvalidMinimumHealthyHostValueException$ = InvalidMinimumHealthyHostValueException$;
+exports.InvalidNextTokenException = InvalidNextTokenException;
+exports.InvalidNextTokenException$ = InvalidNextTokenException$;
+exports.InvalidOnPremisesTagCombinationException = InvalidOnPremisesTagCombinationException;
+exports.InvalidOnPremisesTagCombinationException$ = InvalidOnPremisesTagCombinationException$;
+exports.InvalidOperationException = InvalidOperationException;
+exports.InvalidOperationException$ = InvalidOperationException$;
+exports.InvalidRegistrationStatusException = InvalidRegistrationStatusException;
+exports.InvalidRegistrationStatusException$ = InvalidRegistrationStatusException$;
+exports.InvalidRevisionException = InvalidRevisionException;
+exports.InvalidRevisionException$ = InvalidRevisionException$;
+exports.InvalidRoleException = InvalidRoleException;
+exports.InvalidRoleException$ = InvalidRoleException$;
+exports.InvalidSortByException = InvalidSortByException;
+exports.InvalidSortByException$ = InvalidSortByException$;
+exports.InvalidSortOrderException = InvalidSortOrderException;
+exports.InvalidSortOrderException$ = InvalidSortOrderException$;
+exports.InvalidTagException = InvalidTagException;
+exports.InvalidTagException$ = InvalidTagException$;
+exports.InvalidTagFilterException = InvalidTagFilterException;
+exports.InvalidTagFilterException$ = InvalidTagFilterException$;
+exports.InvalidTagsToAddException = InvalidTagsToAddException;
+exports.InvalidTagsToAddException$ = InvalidTagsToAddException$;
+exports.InvalidTargetFilterNameException = InvalidTargetFilterNameException;
+exports.InvalidTargetFilterNameException$ = InvalidTargetFilterNameException$;
+exports.InvalidTargetGroupPairException = InvalidTargetGroupPairException;
+exports.InvalidTargetGroupPairException$ = InvalidTargetGroupPairException$;
+exports.InvalidTargetInstancesException = InvalidTargetInstancesException;
+exports.InvalidTargetInstancesException$ = InvalidTargetInstancesException$;
+exports.InvalidTimeRangeException = InvalidTimeRangeException;
+exports.InvalidTimeRangeException$ = InvalidTimeRangeException$;
+exports.InvalidTrafficRoutingConfigurationException = InvalidTrafficRoutingConfigurationException;
+exports.InvalidTrafficRoutingConfigurationException$ = InvalidTrafficRoutingConfigurationException$;
+exports.InvalidTriggerConfigException = InvalidTriggerConfigException;
+exports.InvalidTriggerConfigException$ = InvalidTriggerConfigException$;
+exports.InvalidUpdateOutdatedInstancesOnlyValueException = InvalidUpdateOutdatedInstancesOnlyValueException;
+exports.InvalidUpdateOutdatedInstancesOnlyValueException$ = InvalidUpdateOutdatedInstancesOnlyValueException$;
+exports.InvalidZonalDeploymentConfigurationException = InvalidZonalDeploymentConfigurationException;
+exports.InvalidZonalDeploymentConfigurationException$ = InvalidZonalDeploymentConfigurationException$;
+exports.LambdaFunctionInfo$ = LambdaFunctionInfo$;
+exports.LambdaTarget$ = LambdaTarget$;
+exports.LastDeploymentInfo$ = LastDeploymentInfo$;
 exports.LifecycleErrorCode = LifecycleErrorCode;
+exports.LifecycleEvent$ = LifecycleEvent$;
+exports.LifecycleEventAlreadyCompletedException = LifecycleEventAlreadyCompletedException;
+exports.LifecycleEventAlreadyCompletedException$ = LifecycleEventAlreadyCompletedException$;
 exports.LifecycleEventStatus = LifecycleEventStatus;
+exports.LifecycleHookLimitExceededException = LifecycleHookLimitExceededException;
+exports.LifecycleHookLimitExceededException$ = LifecycleHookLimitExceededException$;
+exports.ListApplicationRevisions$ = ListApplicationRevisions$;
 exports.ListApplicationRevisionsCommand = ListApplicationRevisionsCommand;
+exports.ListApplicationRevisionsInput$ = ListApplicationRevisionsInput$;
+exports.ListApplicationRevisionsOutput$ = ListApplicationRevisionsOutput$;
+exports.ListApplications$ = ListApplications$;
 exports.ListApplicationsCommand = ListApplicationsCommand;
+exports.ListApplicationsInput$ = ListApplicationsInput$;
+exports.ListApplicationsOutput$ = ListApplicationsOutput$;
+exports.ListDeploymentConfigs$ = ListDeploymentConfigs$;
 exports.ListDeploymentConfigsCommand = ListDeploymentConfigsCommand;
+exports.ListDeploymentConfigsInput$ = ListDeploymentConfigsInput$;
+exports.ListDeploymentConfigsOutput$ = ListDeploymentConfigsOutput$;
+exports.ListDeploymentGroups$ = ListDeploymentGroups$;
 exports.ListDeploymentGroupsCommand = ListDeploymentGroupsCommand;
+exports.ListDeploymentGroupsInput$ = ListDeploymentGroupsInput$;
+exports.ListDeploymentGroupsOutput$ = ListDeploymentGroupsOutput$;
+exports.ListDeploymentInstances$ = ListDeploymentInstances$;
 exports.ListDeploymentInstancesCommand = ListDeploymentInstancesCommand;
+exports.ListDeploymentInstancesInput$ = ListDeploymentInstancesInput$;
+exports.ListDeploymentInstancesOutput$ = ListDeploymentInstancesOutput$;
+exports.ListDeploymentTargets$ = ListDeploymentTargets$;
 exports.ListDeploymentTargetsCommand = ListDeploymentTargetsCommand;
+exports.ListDeploymentTargetsInput$ = ListDeploymentTargetsInput$;
+exports.ListDeploymentTargetsOutput$ = ListDeploymentTargetsOutput$;
+exports.ListDeployments$ = ListDeployments$;
 exports.ListDeploymentsCommand = ListDeploymentsCommand;
+exports.ListDeploymentsInput$ = ListDeploymentsInput$;
+exports.ListDeploymentsOutput$ = ListDeploymentsOutput$;
+exports.ListGitHubAccountTokenNames$ = ListGitHubAccountTokenNames$;
 exports.ListGitHubAccountTokenNamesCommand = ListGitHubAccountTokenNamesCommand;
+exports.ListGitHubAccountTokenNamesInput$ = ListGitHubAccountTokenNamesInput$;
+exports.ListGitHubAccountTokenNamesOutput$ = ListGitHubAccountTokenNamesOutput$;
+exports.ListOnPremisesInstances$ = ListOnPremisesInstances$;
 exports.ListOnPremisesInstancesCommand = ListOnPremisesInstancesCommand;
+exports.ListOnPremisesInstancesInput$ = ListOnPremisesInstancesInput$;
+exports.ListOnPremisesInstancesOutput$ = ListOnPremisesInstancesOutput$;
 exports.ListStateFilterAction = ListStateFilterAction;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceInput$ = ListTagsForResourceInput$;
+exports.ListTagsForResourceOutput$ = ListTagsForResourceOutput$;
+exports.LoadBalancerInfo$ = LoadBalancerInfo$;
+exports.MinimumHealthyHosts$ = MinimumHealthyHosts$;
+exports.MinimumHealthyHostsPerZone$ = MinimumHealthyHostsPerZone$;
 exports.MinimumHealthyHostsPerZoneType = MinimumHealthyHostsPerZoneType;
 exports.MinimumHealthyHostsType = MinimumHealthyHostsType;
+exports.MultipleIamArnsProvidedException = MultipleIamArnsProvidedException;
+exports.MultipleIamArnsProvidedException$ = MultipleIamArnsProvidedException$;
+exports.OnPremisesTagSet$ = OnPremisesTagSet$;
+exports.OperationNotSupportedException = OperationNotSupportedException;
+exports.OperationNotSupportedException$ = OperationNotSupportedException$;
 exports.OutdatedInstancesStrategy = OutdatedInstancesStrategy;
+exports.PutLifecycleEventHookExecutionStatus$ = PutLifecycleEventHookExecutionStatus$;
 exports.PutLifecycleEventHookExecutionStatusCommand = PutLifecycleEventHookExecutionStatusCommand;
+exports.PutLifecycleEventHookExecutionStatusInput$ = PutLifecycleEventHookExecutionStatusInput$;
+exports.PutLifecycleEventHookExecutionStatusOutput$ = PutLifecycleEventHookExecutionStatusOutput$;
+exports.RawString$ = RawString$;
+exports.RegisterApplicationRevision$ = RegisterApplicationRevision$;
 exports.RegisterApplicationRevisionCommand = RegisterApplicationRevisionCommand;
+exports.RegisterApplicationRevisionInput$ = RegisterApplicationRevisionInput$;
+exports.RegisterOnPremisesInstance$ = RegisterOnPremisesInstance$;
 exports.RegisterOnPremisesInstanceCommand = RegisterOnPremisesInstanceCommand;
+exports.RegisterOnPremisesInstanceInput$ = RegisterOnPremisesInstanceInput$;
 exports.RegistrationStatus = RegistrationStatus;
+exports.RelatedDeployments$ = RelatedDeployments$;
+exports.RemoveTagsFromOnPremisesInstances$ = RemoveTagsFromOnPremisesInstances$;
 exports.RemoveTagsFromOnPremisesInstancesCommand = RemoveTagsFromOnPremisesInstancesCommand;
+exports.RemoveTagsFromOnPremisesInstancesInput$ = RemoveTagsFromOnPremisesInstancesInput$;
+exports.ResourceArnRequiredException = ResourceArnRequiredException;
+exports.ResourceArnRequiredException$ = ResourceArnRequiredException$;
+exports.ResourceValidationException = ResourceValidationException;
+exports.ResourceValidationException$ = ResourceValidationException$;
+exports.RevisionDoesNotExistException = RevisionDoesNotExistException;
+exports.RevisionDoesNotExistException$ = RevisionDoesNotExistException$;
+exports.RevisionInfo$ = RevisionInfo$;
+exports.RevisionLocation$ = RevisionLocation$;
 exports.RevisionLocationType = RevisionLocationType;
+exports.RevisionRequiredException = RevisionRequiredException;
+exports.RevisionRequiredException$ = RevisionRequiredException$;
+exports.RoleRequiredException = RoleRequiredException;
+exports.RoleRequiredException$ = RoleRequiredException$;
+exports.RollbackInfo$ = RollbackInfo$;
+exports.S3Location$ = S3Location$;
+exports.SkipWaitTimeForInstanceTermination$ = SkipWaitTimeForInstanceTermination$;
 exports.SkipWaitTimeForInstanceTerminationCommand = SkipWaitTimeForInstanceTerminationCommand;
+exports.SkipWaitTimeForInstanceTerminationInput$ = SkipWaitTimeForInstanceTerminationInput$;
 exports.SortOrder = SortOrder;
+exports.StopDeployment$ = StopDeployment$;
 exports.StopDeploymentCommand = StopDeploymentCommand;
+exports.StopDeploymentInput$ = StopDeploymentInput$;
+exports.StopDeploymentOutput$ = StopDeploymentOutput$;
 exports.StopStatus = StopStatus;
+exports.Tag$ = Tag$;
+exports.TagFilter$ = TagFilter$;
 exports.TagFilterType = TagFilterType;
+exports.TagLimitExceededException = TagLimitExceededException;
+exports.TagLimitExceededException$ = TagLimitExceededException$;
+exports.TagRequiredException = TagRequiredException;
+exports.TagRequiredException$ = TagRequiredException$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceInput$ = TagResourceInput$;
+exports.TagResourceOutput$ = TagResourceOutput$;
+exports.TagSetListLimitExceededException = TagSetListLimitExceededException;
+exports.TagSetListLimitExceededException$ = TagSetListLimitExceededException$;
 exports.TargetFilterName = TargetFilterName;
+exports.TargetGroupInfo$ = TargetGroupInfo$;
+exports.TargetGroupPairInfo$ = TargetGroupPairInfo$;
+exports.TargetInstances$ = TargetInstances$;
 exports.TargetLabel = TargetLabel;
 exports.TargetStatus = TargetStatus;
+exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException$ = ThrottlingException$;
+exports.TimeBasedCanary$ = TimeBasedCanary$;
+exports.TimeBasedLinear$ = TimeBasedLinear$;
+exports.TimeRange$ = TimeRange$;
+exports.TrafficRoute$ = TrafficRoute$;
+exports.TrafficRoutingConfig$ = TrafficRoutingConfig$;
 exports.TrafficRoutingType = TrafficRoutingType;
+exports.TriggerConfig$ = TriggerConfig$;
 exports.TriggerEventType = TriggerEventType;
+exports.TriggerTargetsLimitExceededException = TriggerTargetsLimitExceededException;
+exports.TriggerTargetsLimitExceededException$ = TriggerTargetsLimitExceededException$;
+exports.UnsupportedActionForDeploymentTypeException = UnsupportedActionForDeploymentTypeException;
+exports.UnsupportedActionForDeploymentTypeException$ = UnsupportedActionForDeploymentTypeException$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceInput$ = UntagResourceInput$;
+exports.UntagResourceOutput$ = UntagResourceOutput$;
+exports.UpdateApplication$ = UpdateApplication$;
 exports.UpdateApplicationCommand = UpdateApplicationCommand;
+exports.UpdateApplicationInput$ = UpdateApplicationInput$;
+exports.UpdateDeploymentGroup$ = UpdateDeploymentGroup$;
 exports.UpdateDeploymentGroupCommand = UpdateDeploymentGroupCommand;
+exports.UpdateDeploymentGroupInput$ = UpdateDeploymentGroupInput$;
+exports.UpdateDeploymentGroupOutput$ = UpdateDeploymentGroupOutput$;
+exports.ZonalConfig$ = ZonalConfig$;
 exports._InstanceType = _InstanceType;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateListApplicationRevisions = paginateListApplicationRevisions;
 exports.paginateListApplications = paginateListApplications;
 exports.paginateListDeploymentConfigs = paginateListDeploymentConfigs;