lambda-live-debugger/node_modules/@aws-sdk/client-lambda/dist-cjs/index.js

Debug Lambda functions locally like it is running in the cloud

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 { normalizeProvider, getSmithyContext, ServiceException: ServiceException$1, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
const { Command: $Command } = require("@smithy/core/client");
exports.$Command = $Command;
exports.__Client = Client;
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 { eventStreamSerdeProvider, resolveEventStreamSerdeConfig } = require("@smithy/core/event-streams");
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, calculateBodyLength } = require("@smithy/core/serde");
const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
const { Sha256 } = require("@smithy/core/checksum");

const defaultLambdaHttpAuthSchemeParametersProvider = 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: "lambda",
            region: authParameters.region,
        },
        propertiesExtractor: (config, context) => ({
            signingProperties: {
                config,
                context,
            },
        }),
    };
}
const defaultLambdaHttpAuthSchemeProvider = (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, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "lambda",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

var version = "3.1084.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://lambda-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
        ["https://lambda-fips.{Region}.{PartitionResult#dnsSuffix}", i],
        [a, "FIPS is enabled but this partition does not support FIPS"],
        ["https://lambda.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
        [a, "DualStack is enabled but this partition does not support DualStack"],
        ["https://lambda.{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 LambdaServiceException extends ServiceException$1 {
    constructor(options) {
        super(options);
        Object.setPrototypeOf(this, LambdaServiceException.prototype);
    }
}

class InvalidParameterValueException extends LambdaServiceException {
    name = "InvalidParameterValueException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "InvalidParameterValueException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
        this.Type = opts.Type;
    }
}
class PolicyLengthExceededException extends LambdaServiceException {
    name = "PolicyLengthExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "PolicyLengthExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PolicyLengthExceededException.prototype);
        this.Type = opts.Type;
    }
}
class PreconditionFailedException extends LambdaServiceException {
    name = "PreconditionFailedException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "PreconditionFailedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PreconditionFailedException.prototype);
        this.Type = opts.Type;
    }
}
class ResourceConflictException extends LambdaServiceException {
    name = "ResourceConflictException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "ResourceConflictException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceConflictException.prototype);
        this.Type = opts.Type;
    }
}
class ResourceNotFoundException extends LambdaServiceException {
    name = "ResourceNotFoundException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ResourceNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class ServiceException extends LambdaServiceException {
    name = "ServiceException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ServiceException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, ServiceException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class TooManyRequestsException extends LambdaServiceException {
    name = "TooManyRequestsException";
    $fault = "client";
    retryAfterSeconds;
    Type;
    Reason;
    constructor(opts) {
        super({
            name: "TooManyRequestsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
        this.retryAfterSeconds = opts.retryAfterSeconds;
        this.Type = opts.Type;
        this.Reason = opts.Reason;
    }
}
class PublicPolicyException extends LambdaServiceException {
    name = "PublicPolicyException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "PublicPolicyException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PublicPolicyException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class AliasLimitExceededException extends LambdaServiceException {
    name = "AliasLimitExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "AliasLimitExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, AliasLimitExceededException.prototype);
        this.Type = opts.Type;
    }
}
class CapacityProviderLimitExceededException extends LambdaServiceException {
    name = "CapacityProviderLimitExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CapacityProviderLimitExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CapacityProviderLimitExceededException.prototype);
        this.Type = opts.Type;
    }
}
class KMSAccessDeniedException extends LambdaServiceException {
    name = "KMSAccessDeniedException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "KMSAccessDeniedException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, KMSAccessDeniedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class KMSDisabledException extends LambdaServiceException {
    name = "KMSDisabledException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "KMSDisabledException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, KMSDisabledException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class KMSInvalidStateException extends LambdaServiceException {
    name = "KMSInvalidStateException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "KMSInvalidStateException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, KMSInvalidStateException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class KMSNotFoundException extends LambdaServiceException {
    name = "KMSNotFoundException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "KMSNotFoundException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, KMSNotFoundException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class ResourceInUseException extends LambdaServiceException {
    name = "ResourceInUseException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ResourceInUseException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceInUseException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class CodeSigningConfigNotFoundException extends LambdaServiceException {
    name = "CodeSigningConfigNotFoundException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "CodeSigningConfigNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeSigningConfigNotFoundException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class CodeStorageExceededException extends LambdaServiceException {
    name = "CodeStorageExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CodeStorageExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeStorageExceededException.prototype);
        this.Type = opts.Type;
    }
}
class CodeVerificationFailedException extends LambdaServiceException {
    name = "CodeVerificationFailedException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "CodeVerificationFailedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeVerificationFailedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class FunctionVersionsPerCapacityProviderLimitExceededException extends LambdaServiceException {
    name = "FunctionVersionsPerCapacityProviderLimitExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "FunctionVersionsPerCapacityProviderLimitExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, FunctionVersionsPerCapacityProviderLimitExceededException.prototype);
        this.Type = opts.Type;
    }
}
class InvalidCodeSignatureException extends LambdaServiceException {
    name = "InvalidCodeSignatureException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "InvalidCodeSignatureException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidCodeSignatureException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class CodeArtifactUserDeletedException extends LambdaServiceException {
    name = "CodeArtifactUserDeletedException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CodeArtifactUserDeletedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeArtifactUserDeletedException.prototype);
        this.Type = opts.Type;
    }
}
class CodeArtifactUserFailedException extends LambdaServiceException {
    name = "CodeArtifactUserFailedException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CodeArtifactUserFailedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeArtifactUserFailedException.prototype);
        this.Type = opts.Type;
    }
}
class CodeArtifactUserPendingException extends LambdaServiceException {
    name = "CodeArtifactUserPendingException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CodeArtifactUserPendingException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeArtifactUserPendingException.prototype);
        this.Type = opts.Type;
    }
}
class DurableExecutionAlreadyStartedException extends LambdaServiceException {
    name = "DurableExecutionAlreadyStartedException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "DurableExecutionAlreadyStartedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, DurableExecutionAlreadyStartedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EC2AccessDeniedException extends LambdaServiceException {
    name = "EC2AccessDeniedException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EC2AccessDeniedException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, EC2AccessDeniedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EC2ThrottledException extends LambdaServiceException {
    name = "EC2ThrottledException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EC2ThrottledException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, EC2ThrottledException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EC2UnexpectedException extends LambdaServiceException {
    name = "EC2UnexpectedException";
    $fault = "server";
    Type;
    Message;
    EC2ErrorCode;
    constructor(opts) {
        super({
            name: "EC2UnexpectedException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, EC2UnexpectedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
        this.EC2ErrorCode = opts.EC2ErrorCode;
    }
}
class EFSIOException extends LambdaServiceException {
    name = "EFSIOException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EFSIOException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EFSIOException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EFSMountConnectivityException extends LambdaServiceException {
    name = "EFSMountConnectivityException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EFSMountConnectivityException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EFSMountConnectivityException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EFSMountFailureException extends LambdaServiceException {
    name = "EFSMountFailureException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EFSMountFailureException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EFSMountFailureException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class EFSMountTimeoutException extends LambdaServiceException {
    name = "EFSMountTimeoutException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "EFSMountTimeoutException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EFSMountTimeoutException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class ENILimitReachedException extends LambdaServiceException {
    name = "ENILimitReachedException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ENILimitReachedException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, ENILimitReachedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class ENINotReadyException extends LambdaServiceException {
    name = "ENINotReadyException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ENINotReadyException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, ENINotReadyException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class InvalidRequestContentException extends LambdaServiceException {
    name = "InvalidRequestContentException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "InvalidRequestContentException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidRequestContentException.prototype);
        this.Type = opts.Type;
    }
}
class InvalidRuntimeException extends LambdaServiceException {
    name = "InvalidRuntimeException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "InvalidRuntimeException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidRuntimeException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class InvalidSecurityGroupIDException extends LambdaServiceException {
    name = "InvalidSecurityGroupIDException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "InvalidSecurityGroupIDException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidSecurityGroupIDException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class InvalidSubnetIDException extends LambdaServiceException {
    name = "InvalidSubnetIDException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "InvalidSubnetIDException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidSubnetIDException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class InvalidZipFileException extends LambdaServiceException {
    name = "InvalidZipFileException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "InvalidZipFileException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidZipFileException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class ModeNotSupportedException extends LambdaServiceException {
    name = "ModeNotSupportedException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "ModeNotSupportedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ModeNotSupportedException.prototype);
        this.Type = opts.Type;
    }
}
class NoPublishedVersionException extends LambdaServiceException {
    name = "NoPublishedVersionException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "NoPublishedVersionException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, NoPublishedVersionException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class RecursiveInvocationException extends LambdaServiceException {
    name = "RecursiveInvocationException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "RecursiveInvocationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, RecursiveInvocationException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class RequestTooLargeException extends LambdaServiceException {
    name = "RequestTooLargeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "RequestTooLargeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, RequestTooLargeException.prototype);
        this.Type = opts.Type;
    }
}
class ResourceNotReadyException extends LambdaServiceException {
    name = "ResourceNotReadyException";
    $fault = "server";
    Type;
    constructor(opts) {
        super({
            name: "ResourceNotReadyException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceNotReadyException.prototype);
        this.Type = opts.Type;
    }
}
class S3FilesMountConnectivityException extends LambdaServiceException {
    name = "S3FilesMountConnectivityException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "S3FilesMountConnectivityException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, S3FilesMountConnectivityException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class S3FilesMountFailureException extends LambdaServiceException {
    name = "S3FilesMountFailureException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "S3FilesMountFailureException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, S3FilesMountFailureException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class S3FilesMountTimeoutException extends LambdaServiceException {
    name = "S3FilesMountTimeoutException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "S3FilesMountTimeoutException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, S3FilesMountTimeoutException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SerializedRequestEntityTooLargeException extends LambdaServiceException {
    name = "SerializedRequestEntityTooLargeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "SerializedRequestEntityTooLargeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SerializedRequestEntityTooLargeException.prototype);
        this.Type = opts.Type;
    }
}
class ServiceQuotaExceededException extends LambdaServiceException {
    name = "ServiceQuotaExceededException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "ServiceQuotaExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SnapStartException extends LambdaServiceException {
    name = "SnapStartException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "SnapStartException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SnapStartException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SnapStartNotReadyException extends LambdaServiceException {
    name = "SnapStartNotReadyException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "SnapStartNotReadyException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SnapStartNotReadyException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SnapStartRegenerationFailureException extends LambdaServiceException {
    name = "SnapStartRegenerationFailureException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "SnapStartRegenerationFailureException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SnapStartRegenerationFailureException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SnapStartTimeoutException extends LambdaServiceException {
    name = "SnapStartTimeoutException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "SnapStartTimeoutException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SnapStartTimeoutException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class SubnetIPAddressLimitReachedException extends LambdaServiceException {
    name = "SubnetIPAddressLimitReachedException";
    $fault = "server";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "SubnetIPAddressLimitReachedException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, SubnetIPAddressLimitReachedException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}
class UnsupportedMediaTypeException extends LambdaServiceException {
    name = "UnsupportedMediaTypeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "UnsupportedMediaTypeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedMediaTypeException.prototype);
        this.Type = opts.Type;
    }
}
class ProvisionedConcurrencyConfigNotFoundException extends LambdaServiceException {
    name = "ProvisionedConcurrencyConfigNotFoundException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "ProvisionedConcurrencyConfigNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ProvisionedConcurrencyConfigNotFoundException.prototype);
        this.Type = opts.Type;
    }
}
class CallbackTimeoutException extends LambdaServiceException {
    name = "CallbackTimeoutException";
    $fault = "client";
    Type;
    Message;
    constructor(opts) {
        super({
            name: "CallbackTimeoutException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CallbackTimeoutException.prototype);
        this.Type = opts.Type;
        this.Message = opts.Message;
    }
}

const _A = "Action";
const _AA = "AliasArn";
const _AC = "AliasConfiguration";
const _ACc = "AccessConfigs";
const _ACl = "AllowCredentials";
const _AFSC = "AppliedFunctionScalingConfig";
const _AH = "AllowHeaders";
const _AIT = "AllowedInstanceTypes";
const _AL = "AccountLimit";
const _ALEE = "AliasLimitExceededException";
const _ALL = "ApplicationLogLevel";
const _ALVP = "AddLayerVersionPermission";
const _ALVPR = "AddLayerVersionPermissionRequest";
const _ALVPRd = "AddLayerVersionPermissionResponse";
const _ALl = "AliasList";
const _AM = "AllowMethods";
const _AMKESC = "AmazonManagedKafkaEventSourceConfig";
const _AO = "AllowOrigins";
const _AOp = "ApplyOn";
const _AP = "AllowedPublishers";
const _APCE = "AvailableProvisionedConcurrentExecutions";
const _APCEl = "AllocatedProvisionedConcurrentExecutions";
const _APR = "AddPermissionRequest";
const _APRd = "AddPermissionResponse";
const _APd = "AddPermission";
const _ARC = "AliasRoutingConfiguration";
const _AT = "AuthType";
const _AU = "AccountUsage";
const _AVW = "AdditionalVersionWeights";
const _Al = "Aliases";
const _Ar = "Architectures";
const _Arn = "Arn";
const _At = "Attribute";
const _Att = "Attempt";
const _B = "Blob";
const _BBOFE = "BisectBatchOnFunctionError";
const _BOP = "BinaryOperationPayload";
const _BS = "BlobStream";
const _BSa = "BatchSize";
const _C = "Concurrency";
const _CA = "CompatibleArchitectures";
const _CAR = "CreateAliasRequest";
const _CAUDE = "CodeArtifactUserDeletedException";
const _CAUFE = "CodeArtifactUserFailedException";
const _CAUPE = "CodeArtifactUserPendingException";
const _CAo = "CompatibleArchitecture";
const _CAr = "CreateAlias";
const _CAu = "CurrentAttempt";
const _CC = "ClientContext";
const _CCP = "CreateCapacityProvider";
const _CCPR = "CreateCapacityProviderRequest";
const _CCPRr = "CreateCapacityProviderResponse";
const _CCSC = "CreateCodeSigningConfig";
const _CCSCR = "CreateCodeSigningConfigRequest";
const _CCSCRr = "CreateCodeSigningConfigResponse";
const _CD = "CallbackDetails";
const _CDE = "CheckpointDurableExecution";
const _CDER = "CheckpointDurableExecutionRequest";
const _CDERh = "CheckpointDurableExecutionResponse";
const _CDo = "ContextDetails";
const _CDr = "CreatedDate";
const _CE = "ConcurrentExecutions";
const _CESM = "CreateEventSourceMapping";
const _CESMR = "CreateEventSourceMappingRequest";
const _CF = "CreateFunction";
const _CFD = "CallbackFailedDetails";
const _CFDo = "ContextFailedDetails";
const _CFR = "CreateFunctionRequest";
const _CFUC = "CreateFunctionUrlConfig";
const _CFUCR = "CreateFunctionUrlConfigRequest";
const _CFUCRr = "CreateFunctionUrlConfigResponse";
const _CGI = "ConsumerGroupId";
const _CI = "CallbackId";
const _CID = "ChainedInvokeDetails";
const _CIFD = "ChainedInvokeFailedDetails";
const _CIO = "ChainedInvokeOptions";
const _CISD = "ChainedInvokeStartedDetails";
const _CISDh = "ChainedInvokeStoppedDetails";
const _CISDha = "ChainedInvokeSucceededDetails";
const _CITOD = "ChainedInvokeTimedOutDetails";
const _CN = "CollectionName";
const _CO = "CallbackOptions";
const _COo = "ContextOptions";
const _CP = "CapacityProvider";
const _CPA = "CapacityProviderArn";
const _CPC = "CapacityProviderConfig";
const _CPL = "CapacityProvidersList";
const _CPLC = "CapacityProviderLoggingConfig";
const _CPLEE = "CapacityProviderLimitExceededException";
const _CPN = "CapacityProviderName";
const _CPORA = "CapacityProviderOperatorRoleArn";
const _CPPC = "CapacityProviderPermissionsConfig";
const _CPSC = "CapacityProviderScalingConfig";
const _CPSPL = "CapacityProviderScalingPoliciesList";
const _CPTC = "CapacityProviderTelemetryConfig";
const _CPVC = "CapacityProviderVpcConfig";
const _CPa = "CapacityProviders";
const _CR = "CompatibleRuntimes";
const _CRo = "CompatibleRuntime";
const _CS = "CodeSize";
const _CSC = "CodeSigningConfig";
const _CSCA = "CodeSigningConfigArn";
const _CSCI = "CodeSigningConfigId";
const _CSCL = "CodeSigningConfigList";
const _CSCNFE = "CodeSigningConfigNotFoundException";
const _CSCo = "CodeSigningConfigs";
const _CSD = "CallbackStartedDetails";
const _CSDa = "CallbackSucceededDetails";
const _CSDo = "ContextStartedDetails";
const _CSDon = "ContextSucceededDetails";
const _CSEE = "CodeStorageExceededException";
const _CSP = "CodeSigningPolicies";
const _CSU = "CodeSizeUnzipped";
const _CSZ = "CodeSizeZipped";
const _CSo = "CodeSha256";
const _CSon = "ConfigSha256";
const _CT = "CheckpointToken";
const _CTE = "CallbackTimeoutException";
const _CTOD = "CallbackTimedOutDetails";
const _CT_ = "Content-Type";
const _CTl = "ClientToken";
const _CTr = "CreationTime";
const _CUES = "CheckpointUpdatedExecutionState";
const _CVFE = "CodeVerificationFailedException";
const _Co = "Cors";
const _Cod = "Code";
const _Com = "Command";
const _Con = "Configuration";
const _Cont = "Content";
const _D = "Description";
const _DA = "DeleteAlias";
const _DAR = "DeleteAliasRequest";
const _DC = "DestinationConfig";
const _DCP = "DeleteCapacityProvider";
const _DCPR = "DeleteCapacityProviderRequest";
const _DCPRe = "DeleteCapacityProviderResponse";
const _DCSC = "DeleteCodeSigningConfig";
const _DCSCR = "DeleteCodeSigningConfigRequest";
const _DCSCRe = "DeleteCodeSigningConfigResponse";
const _DCu = "DurableConfig";
const _DDBESC = "DocumentDBEventSourceConfig";
const _DE = "DurableExecutions";
const _DEA = "DurableExecutionArn";
const _DEASE = "DurableExecutionAlreadyStartedException";
const _DEN = "DurableExecutionName";
const _DESM = "DeleteEventSourceMapping";
const _DESMR = "DeleteEventSourceMappingRequest";
const _DF = "DeleteFunction";
const _DFC = "DeleteFunctionConcurrency";
const _DFCR = "DeleteFunctionConcurrencyRequest";
const _DFCSC = "DeleteFunctionCodeSigningConfig";
const _DFCSCR = "DeleteFunctionCodeSigningConfigRequest";
const _DFEIC = "DeleteFunctionEventInvokeConfig";
const _DFEICR = "DeleteFunctionEventInvokeConfigRequest";
const _DFR = "DeleteFunctionRequest";
const _DFRe = "DeleteFunctionResponse";
const _DFUC = "DeleteFunctionUrlConfig";
const _DFUCR = "DeleteFunctionUrlConfigRequest";
const _DLC = "DeadLetterConfig";
const _DLV = "DeleteLayerVersion";
const _DLVR = "DeleteLayerVersionRequest";
const _DN = "DatabaseName";
const _DPCC = "DeleteProvisionedConcurrencyConfig";
const _DPCCR = "DeleteProvisionedConcurrencyConfigRequest";
const _DR = "DryRun";
const _De = "Destination";
const _Du = "Duration";
const _E = "Error";
const _EC = "ErrorCode";
const _ECADE = "EC2AccessDeniedException";
const _ECEC = "EC2ErrorCode";
const _ECTE = "EC2ThrottledException";
const _ECUE = "EC2UnexpectedException";
const _ED = "ErrorData";
const _EDI = "ExecutionDataIncluded";
const _EDr = "ErrorDetails";
const _EDx = "ExecutionDetails";
const _EE = "EnvironmentError";
const _EEMGBPVC = "ExecutionEnvironmentMemoryGiBPerVCpu";
const _EEv = "EventError";
const _EFD = "ExecutionFailedDetails";
const _EFSIOE = "EFSIOException";
const _EFSMCE = "EFSMountConnectivityException";
const _EFSMFE = "EFSMountFailureException";
const _EFSMTE = "EFSMountTimeoutException";
const _EH = "ExposeHeaders";
const _EI = "EventId";
const _EIT = "ExcludedInstanceTypes";
const _EIv = "EventInput";
const _EM = "ErrorMessage";
const _ENILRE = "ENILimitReachedException";
const _ENINRE = "ENINotReadyException";
const _EO = "ErrorObject";
const _EP = "EntryPoint";
const _ER = "EnvironmentResponse";
const _ERF = "EventRecordFormat";
const _ERv = "EventResult";
const _ES = "EphemeralStorage";
const _ESA = "EventSourceArn";
const _ESD = "ExecutionStartedDetails";
const _ESDx = "ExecutionSucceededDetails";
const _ESDxe = "ExecutionStoppedDetails";
const _ESM = "EventSourceMappings";
const _ESMA = "EventSourceMappingArn";
const _ESMC = "EventSourceMappingConfiguration";
const _ESML = "EventSourceMappingsList";
const _ESMLC = "EventSourceMappingLoggingConfig";
const _ESMMC = "EventSourceMappingMetricsConfig";
const _EST = "EventSourceToken";
const _ESv = "EventStream";
const _ET = "ErrorType";
const _ETOD = "ExecutionTimedOutDetails";
const _ETn = "EndTimestamp";
const _ETv = "EventType";
const _ETve = "EventTimestamp";
const _ETx = "ExecutionTimeout";
const _ETxp = "ExplicitTags";
const _EV = "ExecutedVersion";
const _EVN = "EnvironmentVariableName";
const _EVV = "EnvironmentVariableValue";
const _EVn = "EnvironmentVariables";
const _En = "Enabled";
const _End = "Endpoints";
const _Env = "Environment";
const _Ev = "Event";
const _Eve = "Events";
const _Ex = "Execution";
const _F = "Filter";
const _FA = "FunctionArn";
const _FAu = "FunctionArns";
const _FC = "FunctionCount";
const _FCE = "FilterCriteriaError";
const _FCL = "FunctionCodeLocation";
const _FCLE = "FunctionCodeLocationError";
const _FCi = "FilterCriteria";
const _FCu = "FunctionCode";
const _FCun = "FunctionConfiguration";
const _FD = "FullDocument";
const _FE = "FunctionError";
const _FEIC = "FunctionEventInvokeConfig";
const _FEICL = "FunctionEventInvokeConfigList";
const _FEICu = "FunctionEventInvokeConfigs";
const _FL = "FilterList";
const _FLu = "FunctionList";
const _FN = "FunctionName";
const _FRT = "FunctionResponseTypes";
const _FS = "FunctionState";
const _FSC = "FileSystemConfigs";
const _FSCL = "FileSystemConfigList";
const _FSCi = "FileSystemConfig";
const _FSCu = "FunctionScalingConfig";
const _FU = "FunctionUrl";
const _FUAT = "FunctionUrlAuthType";
const _FUC = "FunctionUrlConfig";
const _FUCL = "FunctionUrlConfigList";
const _FUCu = "FunctionUrlConfigs";
const _FV = "FunctionVersion";
const _FVBCPL = "FunctionVersionsByCapacityProviderList";
const _FVBCPLI = "FunctionVersionsByCapacityProviderListItem";
const _FVPCPLEE = "FunctionVersionsPerCapacityProviderLimitExceededException";
const _FVu = "FunctionVersions";
const _Fi = "Filters";
const _Fu = "Functions";
const _GA = "GetAlias";
const _GAR = "GetAliasRequest";
const _GAS = "GetAccountSettings";
const _GASR = "GetAccountSettingsRequest";
const _GASRe = "GetAccountSettingsResponse";
const _GCP = "GetCapacityProvider";
const _GCPR = "GetCapacityProviderRequest";
const _GCPRe = "GetCapacityProviderResponse";
const _GCSC = "GetCodeSigningConfig";
const _GCSCR = "GetCodeSigningConfigRequest";
const _GCSCRe = "GetCodeSigningConfigResponse";
const _GDE = "GetDurableExecution";
const _GDEH = "GetDurableExecutionHistory";
const _GDEHR = "GetDurableExecutionHistoryRequest";
const _GDEHRe = "GetDurableExecutionHistoryResponse";
const _GDER = "GetDurableExecutionRequest";
const _GDERe = "GetDurableExecutionResponse";
const _GDES = "GetDurableExecutionState";
const _GDESR = "GetDurableExecutionStateRequest";
const _GDESRe = "GetDurableExecutionStateResponse";
const _GESM = "GetEventSourceMapping";
const _GESMR = "GetEventSourceMappingRequest";
const _GF = "GetFunction";
const _GFC = "GetFunctionConcurrency";
const _GFCR = "GetFunctionConcurrencyRequest";
const _GFCRe = "GetFunctionConcurrencyResponse";
const _GFCRet = "GetFunctionConfigurationRequest";
const _GFCSC = "GetFunctionCodeSigningConfig";
const _GFCSCR = "GetFunctionCodeSigningConfigRequest";
const _GFCSCRe = "GetFunctionCodeSigningConfigResponse";
const _GFCe = "GetFunctionConfiguration";
const _GFEIC = "GetFunctionEventInvokeConfig";
const _GFEICR = "GetFunctionEventInvokeConfigRequest";
const _GFR = "GetFunctionRequest";
const _GFRC = "GetFunctionRecursionConfig";
const _GFRCR = "GetFunctionRecursionConfigRequest";
const _GFRCRe = "GetFunctionRecursionConfigResponse";
const _GFRe = "GetFunctionResponse";
const _GFSC = "GetFunctionScalingConfig";
const _GFSCR = "GetFunctionScalingConfigRequest";
const _GFSCRe = "GetFunctionScalingConfigResponse";
const _GFUC = "GetFunctionUrlConfig";
const _GFUCR = "GetFunctionUrlConfigRequest";
const _GFUCRe = "GetFunctionUrlConfigResponse";
const _GLV = "GetLayerVersion";
const _GLVBA = "GetLayerVersionByArn";
const _GLVBAR = "GetLayerVersionByArnRequest";
const _GLVP = "GetLayerVersionPolicy";
const _GLVPR = "GetLayerVersionPolicyRequest";
const _GLVPRe = "GetLayerVersionPolicyResponse";
const _GLVR = "GetLayerVersionRequest";
const _GLVRe = "GetLayerVersionResponse";
const _GP = "GetPolicy";
const _GPCC = "GetProvisionedConcurrencyConfig";
const _GPCCR = "GetProvisionedConcurrencyConfigRequest";
const _GPCCRe = "GetProvisionedConcurrencyConfigResponse";
const _GPR = "GetPolicyRequest";
const _GPRe = "GetPolicyResponse";
const _GRMC = "GetRuntimeManagementConfig";
const _GRMCR = "GetRuntimeManagementConfigRequest";
const _GRMCRe = "GetRuntimeManagementConfigResponse";
const _H = "Handler";
const _HT = "HeartbeatTimeout";
const _HTS = "HeartbeatTimeoutSeconds";
const _I = "Input";
const _IA = "InvokeArgs";
const _IAFDS = "Ipv6AllowedForDualStack";
const _IAR = "InvokeAsyncRequest";
const _IARn = "InvokeAsyncResponse";
const _IAn = "InvokeAsync";
const _IC = "ImageConfig";
const _ICD = "InvocationCompletedDetails";
const _ICE = "ImageConfigError";
const _ICR = "ImageConfigResponse";
const _ICSE = "InvalidCodeSignatureException";
const _ICn = "InvokeComplete";
const _IED = "IncludeExecutionData";
const _IM = "InvokeMode";
const _IP = "InputPayload";
const _IPVE = "InvalidParameterValueException";
const _IR = "InstanceRequirements";
const _IRCE = "InvalidRequestContentException";
const _IRE = "InvalidRuntimeException";
const _IRSU = "InvokeResponseStreamUpdate";
const _IRn = "InvocationRequest";
const _IRnv = "InvocationResponse";
const _ISGIDE = "InvalidSecurityGroupIDException";
const _ISIDE = "InvalidSubnetIDException";
const _IT = "InvocationType";
const _IU = "ImageUri";
const _IVFU = "InvokedViaFunctionUrl";
const _IWRS = "InvokeWithResponseStream";
const _IWRSCE = "InvokeWithResponseStreamCompleteEvent";
const _IWRSR = "InvokeWithResponseStreamRequest";
const _IWRSRE = "InvokeWithResponseStreamResponseEvent";
const _IWRSRn = "InvokeWithResponseStreamResponse";
const _IZFE = "InvalidZipFileException";
const _Id = "Id";
const _In = "Invoke";
const _K = "Key";
const _KKA = "KmsKeyArn";
const _KMSADE = "KMSAccessDeniedException";
const _KMSDE = "KMSDisabledException";
const _KMSISE = "KMSInvalidStateException";
const _KMSKA = "KMSKeyArn";
const _KMSNFE = "KMSNotFoundException";
const _KSRAC = "KafkaSchemaRegistryAccessConfig";
const _KSRACL = "KafkaSchemaRegistryAccessConfigList";
const _KSRC = "KafkaSchemaRegistryConfig";
const _KSVC = "KafkaSchemaValidationConfig";
const _KSVCL = "KafkaSchemaValidationConfigList";
const _L = "Layers";
const _LA = "LayerArn";
const _LAR = "ListAliasesRequest";
const _LARi = "ListAliasesResponse";
const _LAi = "ListAliases";
const _LC = "LoggingConfig";
const _LCP = "ListCapacityProviders";
const _LCPR = "ListCapacityProvidersRequest";
const _LCPRi = "ListCapacityProvidersResponse";
const _LCSC = "ListCodeSigningConfigs";
const _LCSCR = "ListCodeSigningConfigsRequest";
const _LCSCRi = "ListCodeSigningConfigsResponse";
const _LDEBF = "ListDurableExecutionsByFunction";
const _LDEBFR = "ListDurableExecutionsByFunctionRequest";
const _LDEBFRi = "ListDurableExecutionsByFunctionResponse";
const _LESM = "ListEventSourceMappings";
const _LESMR = "ListEventSourceMappingsRequest";
const _LESMRi = "ListEventSourceMappingsResponse";
const _LF = "LogFormat";
const _LFBCSC = "ListFunctionsByCodeSigningConfig";
const _LFBCSCR = "ListFunctionsByCodeSigningConfigRequest";
const _LFBCSCRi = "ListFunctionsByCodeSigningConfigResponse";
const _LFEIC = "ListFunctionEventInvokeConfigs";
const _LFEICR = "ListFunctionEventInvokeConfigsRequest";
const _LFEICRi = "ListFunctionEventInvokeConfigsResponse";
const _LFR = "ListFunctionsRequest";
const _LFRi = "ListFunctionsResponse";
const _LFUC = "ListFunctionUrlConfigs";
const _LFUCR = "ListFunctionUrlConfigsRequest";
const _LFUCRi = "ListFunctionUrlConfigsResponse";
const _LFVBCP = "ListFunctionVersionsByCapacityProvider";
const _LFVBCPR = "ListFunctionVersionsByCapacityProviderRequest";
const _LFVBCPRi = "ListFunctionVersionsByCapacityProviderResponse";
const _LFi = "ListFunctions";
const _LG = "LogGroup";
const _LI = "LicenseInfo";
const _LL = "LayersList";
const _LLI = "LayersListItem";
const _LLR = "ListLayersRequest";
const _LLRi = "ListLayersResponse";
const _LLV = "ListLayerVersions";
const _LLVR = "ListLayerVersionsRequest";
const _LLVRi = "ListLayerVersionsResponse";
const _LLi = "ListLayers";
const _LM = "LastModified";
const _LMICPC = "LambdaManagedInstancesCapacityProviderConfig";
const _LMP = "LocalMountPath";
const _LMT = "LastModifiedTime";
const _LMV = "LatestMatchingVersion";
const _LN = "LayerName";
const _LPCC = "ListProvisionedConcurrencyConfigs";
const _LPCCR = "ListProvisionedConcurrencyConfigsRequest";
const _LPCCRi = "ListProvisionedConcurrencyConfigsResponse";
const _LPR = "LastProcessingResult";
const _LR = "LogResult";
const _LRL = "LayersReferenceList";
const _LT = "LogType";
const _LTR = "ListTagsRequest";
const _LTRi = "ListTagsResponse";
const _LTi = "ListTags";
const _LUS = "LastUpdateStatus";
const _LUSR = "LastUpdateStatusReason";
const _LUSRC = "LastUpdateStatusReasonCode";
const _LV = "LayerVersions";
const _LVA = "LayerVersionArn";
const _LVBF = "ListVersionsByFunction";
const _LVBFR = "ListVersionsByFunctionRequest";
const _LVBFRi = "ListVersionsByFunctionResponse";
const _LVCI = "LayerVersionContentInput";
const _LVCO = "LayerVersionContentOutput";
const _LVL = "LayerVersionsList";
const _LVLI = "LayerVersionsListItem";
const _La = "Layer";
const _Lo = "Location";
const _M = "Message";
const _MA = "MaxAge";
const _MAa = "MasterArn";
const _MBWIS = "MaximumBatchingWindowInSeconds";
const _MC = "MetricsConfig";
const _MCa = "MaximumConcurrency";
const _MEAIS = "MaximumEventAgeInSeconds";
const _MEE = "MinExecutionEnvironments";
const _MEEa = "MaxExecutionEnvironments";
const _MI = "MaxItems";
const _MNSE = "ModeNotSupportedException";
const _MP = "MinimumPollers";
const _MPa = "MaximumPollers";
const _MR = "MasterRegion";
const _MRA = "MaximumRetryAttempts";
const _MRAIS = "MaximumRecordAgeInSeconds";
const _MS = "MemorySize";
const _MVCC = "MaxVCpuCount";
const _Ma = "Marker";
const _Me = "Metrics";
const _Mo = "Mode";
const _N = "Name";
const _NADS = "NextAttemptDelaySeconds";
const _NAT = "NextAttemptTimestamp";
const _NES = "NewExecutionState";
const _NM = "NextMarker";
const _NPVE = "NoPublishedVersionException";
const _O = "Operations";
const _OF = "OnFailure";
const _OI = "OrganizationId";
const _OP = "OperationPayload";
const _OPu = "OutputPayload";
const _OS = "OnSucc