'use strict';

var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
var middlewareLogger = require('@aws-sdk/middleware-logger');
var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var configResolver = require('@smithy/config-resolver');
var core = require('@smithy/core');
var schema = require('@smithy/core/schema');
var eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
var middlewareContentLength = require('@smithy/middleware-content-length');
var middlewareEndpoint = require('@smithy/middleware-endpoint');
var middlewareRetry = require('@smithy/middleware-retry');
var smithyClient = require('@smithy/smithy-client');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var regionConfigResolver = require('@aws-sdk/region-config-resolver');
var protocolHttp = require('@smithy/protocol-http');
var utilWaiter = require('@smithy/util-waiter');

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" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class LambdaClient extends smithyClient.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
        const _config_4 = configResolver.resolveRegionConfig(_config_3);
        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
        const _config_7 = eventstreamSerdeConfigResolver.resolveEventStreamSerdeConfig(_config_6);
        const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
        const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
        this.config = _config_9;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultLambdaHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

let LambdaServiceException$1 = class LambdaServiceException extends smithyClient.ServiceException {
    constructor(options) {
        super(options);
        Object.setPrototypeOf(this, LambdaServiceException.prototype);
    }
};

let InvalidParameterValueException$1 = class InvalidParameterValueException extends LambdaServiceException$1 {
    name = "InvalidParameterValueException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "InvalidParameterValueException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
        this.Type = opts.Type;
    }
};
let PolicyLengthExceededException$1 = class PolicyLengthExceededException extends LambdaServiceException$1 {
    name = "PolicyLengthExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "PolicyLengthExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PolicyLengthExceededException.prototype);
        this.Type = opts.Type;
    }
};
let PreconditionFailedException$1 = class PreconditionFailedException extends LambdaServiceException$1 {
    name = "PreconditionFailedException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "PreconditionFailedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PreconditionFailedException.prototype);
        this.Type = opts.Type;
    }
};
let ResourceConflictException$1 = class ResourceConflictException extends LambdaServiceException$1 {
    name = "ResourceConflictException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "ResourceConflictException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceConflictException.prototype);
        this.Type = opts.Type;
    }
};
let ResourceNotFoundException$1 = class ResourceNotFoundException extends LambdaServiceException$1 {
    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;
    }
};
let ServiceException$1 = class ServiceException extends LambdaServiceException$1 {
    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;
    }
};
const ThrottleReason = {
    CallerRateLimitExceeded: "CallerRateLimitExceeded",
    ConcurrentInvocationLimitExceeded: "ConcurrentInvocationLimitExceeded",
    ConcurrentSnapshotCreateLimitExceeded: "ConcurrentSnapshotCreateLimitExceeded",
    FunctionInvocationRateLimitExceeded: "FunctionInvocationRateLimitExceeded",
    ReservedFunctionConcurrentInvocationLimitExceeded: "ReservedFunctionConcurrentInvocationLimitExceeded",
    ReservedFunctionInvocationRateLimitExceeded: "ReservedFunctionInvocationRateLimitExceeded",
};
let TooManyRequestsException$1 = class TooManyRequestsException extends LambdaServiceException$1 {
    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;
    }
};
const FunctionUrlAuthType = {
    AWS_IAM: "AWS_IAM",
    NONE: "NONE",
};
const KafkaSchemaRegistryAuthType = {
    BASIC_AUTH: "BASIC_AUTH",
    CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
    SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE",
};
const SchemaRegistryEventRecordFormat = {
    JSON: "JSON",
    SOURCE: "SOURCE",
};
const KafkaSchemaValidationAttribute = {
    KEY: "KEY",
    VALUE: "VALUE",
};
const ApplicationLogLevel = {
    Debug: "DEBUG",
    Error: "ERROR",
    Fatal: "FATAL",
    Info: "INFO",
    Trace: "TRACE",
    Warn: "WARN",
};
const Architecture = {
    arm64: "arm64",
    x86_64: "x86_64",
};
const CodeSigningPolicy = {
    Enforce: "Enforce",
    Warn: "Warn",
};
const FullDocument = {
    Default: "Default",
    UpdateLookup: "UpdateLookup",
};
const FunctionResponseType = {
    ReportBatchItemFailures: "ReportBatchItemFailures",
};
const EventSourceMappingMetric = {
    EventCount: "EventCount",
};
const EndPointType = {
    KAFKA_BOOTSTRAP_SERVERS: "KAFKA_BOOTSTRAP_SERVERS",
};
const SourceAccessType = {
    BASIC_AUTH: "BASIC_AUTH",
    CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
    SASL_SCRAM_256_AUTH: "SASL_SCRAM_256_AUTH",
    SASL_SCRAM_512_AUTH: "SASL_SCRAM_512_AUTH",
    SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE",
    VIRTUAL_HOST: "VIRTUAL_HOST",
    VPC_SECURITY_GROUP: "VPC_SECURITY_GROUP",
    VPC_SUBNET: "VPC_SUBNET",
};
const EventSourcePosition = {
    AT_TIMESTAMP: "AT_TIMESTAMP",
    LATEST: "LATEST",
    TRIM_HORIZON: "TRIM_HORIZON",
};
let ResourceInUseException$1 = class ResourceInUseException extends LambdaServiceException$1 {
    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;
    }
};
let CodeSigningConfigNotFoundException$1 = class CodeSigningConfigNotFoundException extends LambdaServiceException$1 {
    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;
    }
};
let CodeStorageExceededException$1 = class CodeStorageExceededException extends LambdaServiceException$1 {
    name = "CodeStorageExceededException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "CodeStorageExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeStorageExceededException.prototype);
        this.Type = opts.Type;
    }
};
let CodeVerificationFailedException$1 = class CodeVerificationFailedException extends LambdaServiceException$1 {
    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;
    }
};
const LogFormat = {
    Json: "JSON",
    Text: "Text",
};
const SystemLogLevel = {
    Debug: "DEBUG",
    Info: "INFO",
    Warn: "WARN",
};
const PackageType = {
    Image: "Image",
    Zip: "Zip",
};
const Runtime = {
    dotnet6: "dotnet6",
    dotnet8: "dotnet8",
    dotnetcore10: "dotnetcore1.0",
    dotnetcore20: "dotnetcore2.0",
    dotnetcore21: "dotnetcore2.1",
    dotnetcore31: "dotnetcore3.1",
    go1x: "go1.x",
    java11: "java11",
    java17: "java17",
    java21: "java21",
    java25: "java25",
    java8: "java8",
    java8al2: "java8.al2",
    nodejs: "nodejs",
    nodejs10x: "nodejs10.x",
    nodejs12x: "nodejs12.x",
    nodejs14x: "nodejs14.x",
    nodejs16x: "nodejs16.x",
    nodejs18x: "nodejs18.x",
    nodejs20x: "nodejs20.x",
    nodejs22x: "nodejs22.x",
    nodejs24x: "nodejs24.x",
    nodejs43: "nodejs4.3",
    nodejs43edge: "nodejs4.3-edge",
    nodejs610: "nodejs6.10",
    nodejs810: "nodejs8.10",
    provided: "provided",
    providedal2: "provided.al2",
    providedal2023: "provided.al2023",
    python27: "python2.7",
    python310: "python3.10",
    python311: "python3.11",
    python312: "python3.12",
    python313: "python3.13",
    python314: "python3.14",
    python36: "python3.6",
    python37: "python3.7",
    python38: "python3.8",
    python39: "python3.9",
    ruby25: "ruby2.5",
    ruby27: "ruby2.7",
    ruby32: "ruby3.2",
    ruby33: "ruby3.3",
    ruby34: "ruby3.4",
};
const SnapStartApplyOn = {
    None: "None",
    PublishedVersions: "PublishedVersions",
};
const TracingMode = {
    Active: "Active",
    PassThrough: "PassThrough",
};
const LastUpdateStatus = {
    Failed: "Failed",
    InProgress: "InProgress",
    Successful: "Successful",
};
const LastUpdateStatusReasonCode = {
    DisabledKMSKey: "DisabledKMSKey",
    EFSIOError: "EFSIOError",
    EFSMountConnectivityError: "EFSMountConnectivityError",
    EFSMountFailure: "EFSMountFailure",
    EFSMountTimeout: "EFSMountTimeout",
    EniLimitExceeded: "EniLimitExceeded",
    FunctionError: "FunctionError",
    ImageAccessDenied: "ImageAccessDenied",
    ImageDeleted: "ImageDeleted",
    InsufficientRolePermissions: "InsufficientRolePermissions",
    InternalError: "InternalError",
    InvalidConfiguration: "InvalidConfiguration",
    InvalidImage: "InvalidImage",
    InvalidRuntime: "InvalidRuntime",
    InvalidSecurityGroup: "InvalidSecurityGroup",
    InvalidStateKMSKey: "InvalidStateKMSKey",
    InvalidSubnet: "InvalidSubnet",
    InvalidZipFileException: "InvalidZipFileException",
    KMSKeyAccessDenied: "KMSKeyAccessDenied",
    KMSKeyNotFound: "KMSKeyNotFound",
    SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
};
const SnapStartOptimizationStatus = {
    Off: "Off",
    On: "On",
};
const State = {
    Active: "Active",
    Failed: "Failed",
    Inactive: "Inactive",
    Pending: "Pending",
};
const StateReasonCode = {
    Creating: "Creating",
    DisabledKMSKey: "DisabledKMSKey",
    EFSIOError: "EFSIOError",
    EFSMountConnectivityError: "EFSMountConnectivityError",
    EFSMountFailure: "EFSMountFailure",
    EFSMountTimeout: "EFSMountTimeout",
    EniLimitExceeded: "EniLimitExceeded",
    FunctionError: "FunctionError",
    Idle: "Idle",
    ImageAccessDenied: "ImageAccessDenied",
    ImageDeleted: "ImageDeleted",
    InsufficientRolePermissions: "InsufficientRolePermissions",
    InternalError: "InternalError",
    InvalidConfiguration: "InvalidConfiguration",
    InvalidImage: "InvalidImage",
    InvalidRuntime: "InvalidRuntime",
    InvalidSecurityGroup: "InvalidSecurityGroup",
    InvalidStateKMSKey: "InvalidStateKMSKey",
    InvalidSubnet: "InvalidSubnet",
    InvalidZipFileException: "InvalidZipFileException",
    KMSKeyAccessDenied: "KMSKeyAccessDenied",
    KMSKeyNotFound: "KMSKeyNotFound",
    Restoring: "Restoring",
    SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
};
let InvalidCodeSignatureException$1 = class InvalidCodeSignatureException extends LambdaServiceException$1 {
    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;
    }
};
const InvokeMode = {
    BUFFERED: "BUFFERED",
    RESPONSE_STREAM: "RESPONSE_STREAM",
};
const RecursiveLoop = {
    Allow: "Allow",
    Terminate: "Terminate",
};
const UpdateRuntimeOn = {
    Auto: "Auto",
    FunctionUpdate: "FunctionUpdate",
    Manual: "Manual",
};
let EC2AccessDeniedException$1 = class EC2AccessDeniedException extends LambdaServiceException$1 {
    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;
    }
};
let EC2ThrottledException$1 = class EC2ThrottledException extends LambdaServiceException$1 {
    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;
    }
};
let EC2UnexpectedException$1 = class EC2UnexpectedException extends LambdaServiceException$1 {
    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;
    }
};
let EFSIOException$1 = class EFSIOException extends LambdaServiceException$1 {
    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;
    }
};
let EFSMountConnectivityException$1 = class EFSMountConnectivityException extends LambdaServiceException$1 {
    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;
    }
};
let EFSMountFailureException$1 = class EFSMountFailureException extends LambdaServiceException$1 {
    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;
    }
};
let EFSMountTimeoutException$1 = class EFSMountTimeoutException extends LambdaServiceException$1 {
    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;
    }
};
let ENILimitReachedException$1 = class ENILimitReachedException extends LambdaServiceException$1 {
    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;
    }
};
let InvalidRequestContentException$1 = class InvalidRequestContentException extends LambdaServiceException$1 {
    name = "InvalidRequestContentException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "InvalidRequestContentException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidRequestContentException.prototype);
        this.Type = opts.Type;
    }
};
let InvalidRuntimeException$1 = class InvalidRuntimeException extends LambdaServiceException$1 {
    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;
    }
};
let InvalidSecurityGroupIDException$1 = class InvalidSecurityGroupIDException extends LambdaServiceException$1 {
    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;
    }
};
let InvalidSubnetIDException$1 = class InvalidSubnetIDException extends LambdaServiceException$1 {
    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;
    }
};
let InvalidZipFileException$1 = class InvalidZipFileException extends LambdaServiceException$1 {
    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;
    }
};
const InvocationType = {
    DryRun: "DryRun",
    Event: "Event",
    RequestResponse: "RequestResponse",
};
const LogType = {
    None: "None",
    Tail: "Tail",
};
let KMSAccessDeniedException$1 = class KMSAccessDeniedException extends LambdaServiceException$1 {
    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;
    }
};
let KMSDisabledException$1 = class KMSDisabledException extends LambdaServiceException$1 {
    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;
    }
};
let KMSInvalidStateException$1 = class KMSInvalidStateException extends LambdaServiceException$1 {
    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;
    }
};
let KMSNotFoundException$1 = class KMSNotFoundException extends LambdaServiceException$1 {
    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;
    }
};
let RecursiveInvocationException$1 = class RecursiveInvocationException extends LambdaServiceException$1 {
    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;
    }
};
let RequestTooLargeException$1 = class RequestTooLargeException extends LambdaServiceException$1 {
    name = "RequestTooLargeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "RequestTooLargeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, RequestTooLargeException.prototype);
        this.Type = opts.Type;
    }
};
let ResourceNotReadyException$1 = class ResourceNotReadyException extends LambdaServiceException$1 {
    name = "ResourceNotReadyException";
    $fault = "server";
    Type;
    constructor(opts) {
        super({
            name: "ResourceNotReadyException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceNotReadyException.prototype);
        this.Type = opts.Type;
    }
};
let SerializedRequestEntityTooLargeException$1 = class SerializedRequestEntityTooLargeException extends LambdaServiceException$1 {
    name = "SerializedRequestEntityTooLargeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "SerializedRequestEntityTooLargeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SerializedRequestEntityTooLargeException.prototype);
        this.Type = opts.Type;
    }
};
let SnapStartException$1 = class SnapStartException extends LambdaServiceException$1 {
    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;
    }
};
let SnapStartNotReadyException$1 = class SnapStartNotReadyException extends LambdaServiceException$1 {
    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;
    }
};
let SnapStartTimeoutException$1 = class SnapStartTimeoutException extends LambdaServiceException$1 {
    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;
    }
};
let SubnetIPAddressLimitReachedException$1 = class SubnetIPAddressLimitReachedException extends LambdaServiceException$1 {
    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;
    }
};
let UnsupportedMediaTypeException$1 = class UnsupportedMediaTypeException extends LambdaServiceException$1 {
    name = "UnsupportedMediaTypeException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "UnsupportedMediaTypeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedMediaTypeException.prototype);
        this.Type = opts.Type;
    }
};
const ResponseStreamingInvocationType = {
    DryRun: "DryRun",
    RequestResponse: "RequestResponse",
};
const FunctionVersion = {
    ALL: "ALL",
};
const ProvisionedConcurrencyStatusEnum = {
    FAILED: "FAILED",
    IN_PROGRESS: "IN_PROGRESS",
    READY: "READY",
};
let ProvisionedConcurrencyConfigNotFoundException$1 = class ProvisionedConcurrencyConfigNotFoundException extends LambdaServiceException$1 {
    name = "ProvisionedConcurrencyConfigNotFoundException";
    $fault = "client";
    Type;
    constructor(opts) {
        super({
            name: "ProvisionedConcurrencyConfigNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ProvisionedConcurrencyConfigNotFoundException.prototype);
        this.Type = opts.Type;
    }
};

const _A = "Action";
const _AA = "AliasArn";
const _AC = "AliasConfiguration";
const _ACc = "AccessConfigs";
const _ACl = "AllowCredentials";
const _AH = "AllowHeaders";
const _AL = "AccountLimit";
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 _B = "Blob";
const _BBOFE = "BisectBatchOnFunctionError";
const _BS = "BlobStream";
const _BSa = "BatchSize";
const _C = "Concurrency";
const _CA = "CompatibleArchitectures";
const _CAR = "CreateAliasRequest";
const _CAo = "CompatibleArchitecture";
const _CAr = "CreateAlias";
const _CC = "ClientContext";
const _CCSC = "CreateCodeSigningConfig";
const _CCSCR = "CreateCodeSigningConfigRequest";
const _CCSCRr = "CreateCodeSigningConfigResponse";
const _CD = "CreatedDate";
const _CE = "ConcurrentExecutions";
const _CESM = "CreateEventSourceMapping";
const _CESMR = "CreateEventSourceMappingRequest";
const _CF = "CreateFunction";
const _CFR = "CreateFunctionRequest";
const _CFUC = "CreateFunctionUrlConfig";
const _CFUCR = "CreateFunctionUrlConfigRequest";
const _CFUCRr = "CreateFunctionUrlConfigResponse";
const _CGI = "ConsumerGroupId";
const _CN = "CollectionName";
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 _CSEE = "CodeStorageExceededException";
const _CSP = "CodeSigningPolicies";
const _CSU = "CodeSizeUnzipped";
const _CSZ = "CodeSizeZipped";
const _CSo = "CodeSha256";
const _CT = "CreationTime";
const _CT_ = "Content-Type";
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 _DCSC = "DeleteCodeSigningConfig";
const _DCSCR = "DeleteCodeSigningConfigRequest";
const _DCSCRe = "DeleteCodeSigningConfigResponse";
const _DDBESC = "DocumentDBEventSourceConfig";
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 _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 _E = "Enabled";
const _EC = "ErrorCode";
const _ECADE = "EC2AccessDeniedException";
const _ECEC = "EC2ErrorCode";
const _ECTE = "EC2ThrottledException";
const _ECUE = "EC2UnexpectedException";
const _ED = "ErrorDetails";
const _EE = "EnvironmentError";
const _EFSIOE = "EFSIOException";
const _EFSMCE = "EFSMountConnectivityException";
const _EFSMFE = "EFSMountFailureException";
const _EFSMTE = "EFSMountTimeoutException";
const _EH = "ExposeHeaders";
const _ENILRE = "ENILimitReachedException";
const _EP = "EntryPoint";
const _ER = "EnvironmentResponse";
const _ERF = "EventRecordFormat";
const _ES = "EphemeralStorage";
const _ESA = "EventSourceArn";
const _ESM = "EventSourceMappings";
const _ESMA = "EventSourceMappingArn";
const _ESMC = "EventSourceMappingConfiguration";
const _ESML = "EventSourceMappingsList";
const _ESMMC = "EventSourceMappingMetricsConfig";
const _EST = "EventSourceToken";
const _ESv = "EventStream";
const _EV = "ExecutedVersion";
const _EVN = "EnvironmentVariableName";
const _EVV = "EnvironmentVariableValue";
const _EVn = "EnvironmentVariables";
const _En = "Environment";
const _End = "Endpoints";
const _Er = "Error";
const _F = "Filter";
const _FA = "FunctionArn";
const _FAu = "FunctionArns";
const _FC = "FunctionCount";
const _FCE = "FilterCriteriaError";
const _FCL = "FunctionCodeLocation";
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 _FSC = "FileSystemConfigs";
const _FSCL = "FileSystemConfigList";
const _FSCi = "FileSystemConfig";
const _FU = "FunctionUrl";
const _FUAT = "FunctionUrlAuthType";
const _FUC = "FunctionUrlConfig";
const _FUCL = "FunctionUrlConfigList";
const _FUCu = "FunctionUrlConfigs";
const _FV = "FunctionVersion";
const _Fi = "Filters";
const _Fu = "Functions";
const _GA = "GetAlias";
const _GAR = "GetAliasRequest";
const _GAS = "GetAccountSettings";
const _GASR = "GetAccountSettingsRequest";
const _GASRe = "GetAccountSettingsResponse";
const _GCSC = "GetCodeSigningConfig";
const _GCSCR = "GetCodeSigningConfigRequest";
const _GCSCRe = "GetCodeSigningConfigResponse";
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 _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 _I = "Invoke";
const _IA = "InvokeArgs";
const _IAFDS = "Ipv6AllowedForDualStack";
const _IAR = "InvokeAsyncRequest";
const _IARn = "InvokeAsyncResponse";
const _IAn = "InvokeAsync";
const _IC = "ImageConfig";
const _ICE = "ImageConfigError";
const _ICR = "ImageConfigResponse";
const _ICSE = "InvalidCodeSignatureException";
const _ICn = "InvokeComplete";
const _IM = "InvokeMode";
const _IPVE = "InvalidParameterValueException";
const _IR = "InvocationRequest";
const _IRCE = "InvalidRequestContentException";
const _IRE = "InvalidRuntimeException";
const _IRSU = "InvokeResponseStreamUpdate";
const _IRn = "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 _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 _LCSC = "ListCodeSigningConfigs";
const _LCSCR = "ListCodeSigningConfigsRequest";
const _LCSCRi = "ListCodeSigningConfigsResponse";
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 _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 _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 _MI = "MaxItems";
const _MP = "MinimumPollers";
const _MPa = "MaximumPollers";
const _MR = "MasterRegion";
const _MRA = "MaximumRetryAttempts";
const _MRAIS = "MaximumRecordAgeInSeconds";
const _MS = "MemorySize";
const _Ma = "Marker";
const _Me = "Metrics";
const _Mo = "Mode";
const _N = "Name";
const _NM = "NextMarker";
const _OF = "OnFailure";
const _OI = "OrganizationId";
const _OS = "OnSuccess";
const _OSp = "OptimizationStatus";
const _P = "Principal";
const _PC = "PayloadChunk";
const _PCC = "ProvisionedConcurrencyConfigs";
const _PCCL = "ProvisionedConcurrencyConfigList";
const _PCCLI = "ProvisionedConcurrencyConfigListItem";
const _PCCNFE = "ProvisionedConcurrencyConfigNotFoundException";
const _PCE = "ProvisionedConcurrentExecutions";
const _PF = "ParallelizationFactor";
const _PFC = "PutFunctionConcurrency";
const _PFCR = "PutFunctionConcurrencyRequest";
const _PFCSC = "PutFunctionCodeSigningConfig";
const _PFCSCR = "PutFunctionCodeSigningConfigRequest";
const _PFCSCRu = "PutFunctionCodeSigningConfigResponse";
const _PFE = "PreconditionFailedException";
const _PFEIC = "PutFunctionEventInvokeConfig";
const _PFEICR = "PutFunctionEventInvokeConfigRequest";
const _PFRC = "PutFunctionRecursionConfig";
const _PFRCR = "PutFunctionRecursionConfigRequest";
const _PFRCRu = "PutFunctionRecursionConfigResponse";
const _PLEE = "PolicyLengthExceededException";
const _PLV = "PublishLayerVersion";
const _PLVR = "PublishLayerVersionRequest";
const _PLVRu = "PublishLayerVersionResponse";
const _POID = "PrincipalOrgID";
const _PPC = "ProvisionedPollerConfig";
const _PPCC = "PutProvisionedConcurrencyConfig";
const _PPCCR = "PutProvisionedConcurrencyConfigRequest";
const _PPCCRu = "PutProvisionedConcurrencyConfigResponse";
const _PRMC = "PutRuntimeManagementConfig";
const _PRMCR = "PutRuntimeManagementConfigRequest";
const _PRMCRu = "PutRuntimeManagementConfigResponse";
const _PT = "PackageType";
const _PV = "PublishVersion";
const _PVR = "PublishVersionRequest";
const _Pa = "Pattern";
const _Pay = "Payload";
const _Po = "Policy";
const _Pu = "Publish";
const _Q = "Qualifier";
const _Qu = "Queues";
const _R = "Runtime";
const _RA = "Retry-After";
const _RC = "RoutingConfig";
const _RCE = "ReservedConcurrentExecutions";
const _RCEe = "ResourceConflictException";
const _RI = "RevisionId";
const _RIE = "RecursiveInvocationException";
const _RIU = "ResolvedImageUri";
const _RIUE = "ResourceInUseException";
const _RL = "RecursiveLoop";
const _RLVP = "RemoveLayerVersionPermission";
const _RLVPR = "RemoveLayerVersionPermissionRequest";
const _RNFE = "ResourceNotFoundException";
const _RNRE = "ResourceNotReadyException";
const _RP = "RemovePermission";
const _RPCE = "RequestedProvisionedConcurrentExecutions";
const _RPR = "RemovePermissionRequest";
const _RSCT = "ResponseStreamContentType";
const _RT = "RepositoryType";
const _RTLE = "RequestTooLargeException";
const _RVA = "RuntimeVersionArn";
const _RVC = "RuntimeVersionConfig";
const _RVE = "RuntimeVersionError";
const _Re = "Resource";
const _Rea = "Reason";
const _Ro = "Role";
const _S = "Statement";
const _SA = "SourceArn";
const _SAC = "SourceAccessConfigurations";
const _SACo = "SourceAccessConfiguration";
const _SAo = "SourceAccount";
const _SB = "S3Bucket";
const _SC = "ScalingConfig";
const _SCt = "StatusCode";
const _SE = "ServiceException";
const _SGI = "SecurityGroupIds";
const _SI = "StatementId";
const _SIPALRE = "SubnetIPAddressLimitReachedException";
const _SIu = "SubnetIds";
const _SJA = "SigningJobArn";
const _SK = "S3Key";
const _SKMSKA = "SourceKMSKeyArn";
const _SLL = "SystemLogLevel";
const _SMES = "SelfManagedEventSource";
const _SMKESC = "SelfManagedKafkaEventSourceConfig";
const _SOV = "S3ObjectVersion";
const _SP = "StartingPosition";
const _SPT = "StartingPositionTimestamp";
const _SPVA = "SigningProfileVersionArns";
const _SPVAi = "SigningProfileVersionArn";
const _SR = "StateReason";
const _SRC = "SchemaRegistryConfig";
const _SRCt = "StateReasonCode";
const _SRETLE = "SerializedRequestEntityTooLargeException";
const _SRURI = "SchemaRegistryURI";
const _SRt = "StatusReason";
const _SS = "SensitiveString";
const _SSE = "SnapStartException";
const _SSNRE = "SnapStartNotReadyException";
const _SSR = "SnapStartResponse";
const _SSTE = "SnapStartTimeoutException";
const _SSn = "SnapStart";
const _STR = "StateTransitionReason";
const _SVC = "SchemaValidationConfigs";
const _Si = "Size";
const _St = "State";
const _Sta = "Status";
const _T = "Type";
const _TA = "TargetArn";
const _TC = "TracingConfig";
const _TCR = "TracingConfigResponse";
const _TCS = "TotalCodeSize";
const _TE = "TagsError";
const _TK = "TagKeys";
const _TMRE = "TooManyRequestsException";
const _TR = "TagResource";
const _TRR = "TagResourceRequest";
const _TWIS = "TumblingWindowInSeconds";
const _Ta = "Tags";
const _Ti = "Timeout";
const _To = "Topics";
const _UA = "UpdateAlias";
const _UAOD = "UntrustedArtifactOnDeployment";
const _UAR = "UpdateAliasRequest";
const _UCE = "UnreservedConcurrentExecutions";
const _UCSC = "UpdateCodeSigningConfig";
const _UCSCR = "UpdateCodeSigningConfigRequest";
const _UCSCRp = "UpdateCodeSigningConfigResponse";
const _UESM = "UpdateEventSourceMapping";
const _UESMR = "UpdateEventSourceMappingRequest";
const _UFC = "UpdateFunctionCode";
const _UFCR = "UpdateFunctionCodeRequest";
const _UFCRp = "UpdateFunctionConfigurationRequest";
const _UFCp = "UpdateFunctionConfiguration";
const _UFEIC = "UpdateFunctionEventInvokeConfig";
const _UFEICR = "UpdateFunctionEventInvokeConfigRequest";
const _UFUC = "UpdateFunctionUrlConfig";
const _UFUCR = "UpdateFunctionUrlConfigRequest";
const _UFUCRp = "UpdateFunctionUrlConfigResponse";
const _UMTE = "UnsupportedMediaTypeException";
const _UR = "UntagResource";
const _URI = "URI";
const _URO = "UpdateRuntimeOn";
const _URR = "UntagResourceRequest";
const _UUID = "UUID";
const _V = "Variables";
const _VC = "VpcConfig";
const _VCR = "VpcConfigResponse";
const _VI = "VpcId";
const _VN = "VersionNumber";
const _Ve = "Version";
const _Ver = "Versions";
const _WD = "WorkingDirectory";
const _XACC = "X-Amz-Client-Context";
const _XAEV = "X-Amz-Executed-Version";
const _XAFE = "X-Amz-Function-Error";
const _XAIT = "X-Amz-Invocation-Type";
const _XALR = "X-Amz-Log-Result";
const _XALT = "X-Amz-Log-Type";
const _ZF = "ZipFile";
const _c = "client";
const _e = "error";
const _eP = "eventPayload";
const _h = "http";
const _hE = "httpError";
const _hH = "httpHeader";
const _hQ = "httpQuery";
const _m = "message";
const _rAS = "retryAfterSeconds";
const _s = "streaming";
const _se = "server";
const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.lambda";
const _tK = "tagKeys";
const n0 = "com.amazonaws.lambda";
var _Blob = [0, n0, _B, 8, 21];
var BlobStream = [
    0,
    n0,
    _BS,
    {
        [_s]: 1,
    },
    42,
];
var EnvironmentVariableName = [0, n0, _EVN, 8, 0];
var EnvironmentVariableValue = [0, n0, _EVV, 8, 0];
var SensitiveString = [0, n0, _SS, 8, 0];
var AccountLimit = [3, n0, _AL, 0, [_TCS, _CSU, _CSZ, _CE, _UCE], [1, 1, 1, 1, 1]];
var AccountUsage = [3, n0, _AU, 0, [_TCS, _FC], [1, 1]];
var AddLayerVersionPermissionRequest = [
    3,
    n0,
    _ALVPR,
    0,
    [_LN, _VN, _SI, _A, _P, _OI, _RI],
    [
        [0, 1],
        [1, 1],
        0,
        0,
        0,
        0,
        [
            0,
            {
                [_hQ]: _RI,
            },
        ],
    ],
];
var AddLayerVersionPermissionResponse = [3, n0, _ALVPRd, 0, [_S, _RI], [0, 0]];
var AddPermissionRequest = [
    3,
    n0,
    _APR,
    0,
    [_FN, _SI, _A, _P, _SA, _SAo, _EST, _Q, _RI, _POID, _FUAT, _IVFU],
    [
        [0, 1],
        0,
        0,
        0,
        0,
        0,
        0,
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        0,
        0,
        0,
        2,
    ],
];
var AddPermissionResponse = [3, n0, _APRd, 0, [_S], [0]];
var AliasConfiguration = [
    3,
    n0,
    _AC,
    0,
    [_AA, _N, _FV, _D, _RC, _RI],
    [0, 0, 0, 0, () => AliasRoutingConfiguration, 0],
];
var AliasRoutingConfiguration = [3, n0, _ARC, 0, [_AVW], [128 | 1]];
var AllowedPublishers = [3, n0, _AP, 0, [_SPVA], [64 | 0]];
var AmazonManagedKafkaEventSourceConfig = [
    3,
    n0,
    _AMKESC,
    0,
    [_CGI, _SRC],
    [0, () => KafkaSchemaRegistryConfig],
];
var CodeSigningConfig = [
    3,
    n0,
    _CSC,
    0,
    [_CSCI, _CSCA, _D, _AP, _CSP, _LM],
    [0, 0, 0, () => AllowedPublishers, () => CodeSigningPolicies, 0],
];
var CodeSigningConfigNotFoundException = [
    -3,
    n0,
    _CSCNFE,
    {
        [_e]: _c,
        [_hE]: 404,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(CodeSigningConfigNotFoundException, CodeSigningConfigNotFoundException$1);
var CodeSigningPolicies = [3, n0, _CSP, 0, [_UAOD], [0]];
var CodeStorageExceededException = [
    -3,
    n0,
    _CSEE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(CodeStorageExceededException, CodeStorageExceededException$1);
var CodeVerificationFailedException = [
    -3,
    n0,
    _CVFE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(CodeVerificationFailedException, CodeVerificationFailedException$1);
var Concurrency = [3, n0, _C, 0, [_RCE], [1]];
var Cors = [
    3,
    n0,
    _Co,
    0,
    [_ACl, _AH, _AM, _AO, _EH, _MA],
    [2, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 1],
];
var CreateAliasRequest = [
    3,
    n0,
    _CAR,
    0,
    [_FN, _N, _FV, _D, _RC],
    [[0, 1], 0, 0, 0, () => AliasRoutingConfiguration],
];
var CreateCodeSigningConfigRequest = [
    3,
    n0,
    _CCSCR,
    0,
    [_D, _AP, _CSP, _Ta],
    [0, () => AllowedPublishers, () => CodeSigningPolicies, 128 | 0],
];
var CreateCodeSigningConfigResponse = [
    3,
    n0,
    _CCSCRr,
    0,
    [_CSC],
    [() => CodeSigningConfig],
];
var CreateEventSourceMappingRequest = [
    3,
    n0,
    _CESMR,
    0,
    [
        _ESA,
        _FN,
        _E,
        _BSa,
        _FCi,
        _MBWIS,
        _PF,
        _SP,
        _SPT,
        _DC,
        _MRAIS,
        _BBOFE,
        _MRA,
        _Ta,
        _TWIS,
        _To,
        _Qu,
        _SAC,
        _SMES,
        _FRT,
        _AMKESC,
        _SMKESC,
        _SC,
        _DDBESC,
        _KMSKA,
        _MC,
        _PPC,
    ],
    [
        0,
        0,
        2,
        1,
        () => FilterCriteria,
        1,
        1,
        0,
        4,
        () => DestinationConfig,
        1,
        2,
        1,
        128 | 0,
        1,
        64 | 0,
        64 | 0,
        () => SourceAccessConfigurations,
        () => SelfManagedEventSource,
        64 | 0,
        () => AmazonManagedKafkaEventSourceConfig,
        () => SelfManagedKafkaEventSourceConfig,
        () => ScalingConfig,
        () => DocumentDBEventSourceConfig,
        0,
        () => EventSourceMappingMetricsConfig,
        () => ProvisionedPollerConfig,
    ],
];
var CreateFunctionRequest = [
    3,
    n0,
    _CFR,
    0,
    [
        _FN,
        _R,
        _Ro,
        _H,
        _Cod,
        _D,
        _Ti,
        _MS,
        _Pu,
        _VC,
        _PT,
        _DLC,
        _En,
        _KMSKA,
        _TC,
        _Ta,
        _L,
        _FSC,
        _IC,
        _CSCA,
        _Ar,
        _ES,
        _SSn,
        _LC,
    ],
    [
        0,
        0,
        0,
        0,
        [() => FunctionCode, 0],
        0,
        1,
        1,
        2,
        () => VpcConfig,
        0,
        () => DeadLetterConfig,
        [() => Environment, 0],
        0,
        () => TracingConfig,
        128 | 0,
        64 | 0,
        () => FileSystemConfigList,
        () => ImageConfig,
        0,
        64 | 0,
        () => EphemeralStorage,
        () => SnapStart,
        () => LoggingConfig,
    ],
];
var CreateFunctionUrlConfigRequest = [
    3,
    n0,
    _CFUCR,
    0,
    [_FN, _Q, _AT, _Co, _IM],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        0,
        () => Cors,
        0,
    ],
];
var CreateFunctionUrlConfigResponse = [
    3,
    n0,
    _CFUCRr,
    0,
    [_FU, _FA, _AT, _Co, _CT, _IM],
    [0, 0, 0, () => Cors, 0, 0],
];
var DeadLetterConfig = [3, n0, _DLC, 0, [_TA], [0]];
var DeleteAliasRequest = [
    3,
    n0,
    _DAR,
    0,
    [_FN, _N],
    [
        [0, 1],
        [0, 1],
    ],
];
var DeleteCodeSigningConfigRequest = [3, n0, _DCSCR, 0, [_CSCA], [[0, 1]]];
var DeleteCodeSigningConfigResponse = [3, n0, _DCSCRe, 0, [], []];
var DeleteEventSourceMappingRequest = [3, n0, _DESMR, 0, [_UUID], [[0, 1]]];
var DeleteFunctionCodeSigningConfigRequest = [3, n0, _DFCSCR, 0, [_FN], [[0, 1]]];
var DeleteFunctionConcurrencyRequest = [3, n0, _DFCR, 0, [_FN], [[0, 1]]];
var DeleteFunctionEventInvokeConfigRequest = [
    3,
    n0,
    _DFEICR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var DeleteFunctionRequest = [
    3,
    n0,
    _DFR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var DeleteFunctionUrlConfigRequest = [
    3,
    n0,
    _DFUCR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var DeleteLayerVersionRequest = [
    3,
    n0,
    _DLVR,
    0,
    [_LN, _VN],
    [
        [0, 1],
        [1, 1],
    ],
];
var DeleteProvisionedConcurrencyConfigRequest = [
    3,
    n0,
    _DPCCR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var DestinationConfig = [3, n0, _DC, 0, [_OS, _OF], [() => OnSuccess, () => OnFailure]];
var DocumentDBEventSourceConfig = [3, n0, _DDBESC, 0, [_DN, _CN, _FD], [0, 0, 0]];
var EC2AccessDeniedException = [
    -3,
    n0,
    _ECADE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EC2AccessDeniedException, EC2AccessDeniedException$1);
var EC2ThrottledException = [
    -3,
    n0,
    _ECTE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EC2ThrottledException, EC2ThrottledException$1);
var EC2UnexpectedException = [
    -3,
    n0,
    _ECUE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M, _ECEC],
    [0, 0, 0],
];
schema.TypeRegistry.for(n0).registerError(EC2UnexpectedException, EC2UnexpectedException$1);
var EFSIOException = [
    -3,
    n0,
    _EFSIOE,
    {
        [_e]: _c,
        [_hE]: 410,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EFSIOException, EFSIOException$1);
var EFSMountConnectivityException = [
    -3,
    n0,
    _EFSMCE,
    {
        [_e]: _c,
        [_hE]: 408,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EFSMountConnectivityException, EFSMountConnectivityException$1);
var EFSMountFailureException = [
    -3,
    n0,
    _EFSMFE,
    {
        [_e]: _c,
        [_hE]: 403,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EFSMountFailureException, EFSMountFailureException$1);
var EFSMountTimeoutException = [
    -3,
    n0,
    _EFSMTE,
    {
        [_e]: _c,
        [_hE]: 408,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(EFSMountTimeoutException, EFSMountTimeoutException$1);
var ENILimitReachedException = [
    -3,
    n0,
    _ENILRE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ENILimitReachedException, ENILimitReachedException$1);
var Environment = [3, n0, _En, 0, [_V], [[() => EnvironmentVariables, 0]]];
var EnvironmentError = [3, n0, _EE, 0, [_EC, _M], [0, [() => SensitiveString, 0]]];
var EnvironmentResponse = [
    3,
    n0,
    _ER,
    0,
    [_V, _Er],
    [
        [() => EnvironmentVariables, 0],
        [() => EnvironmentError, 0],
    ],
];
var EphemeralStorage = [3, n0, _ES, 0, [_Si], [1]];
var EventSourceMappingConfiguration = [
    3,
    n0,
    _ESMC,
    0,
    [
        _UUID,
        _SP,
        _SPT,
        _BSa,
        _MBWIS,
        _PF,
        _ESA,
        _FCi,
        _FA,
        _LM,
        _LPR,
        _St,
        _STR,
        _DC,
        _To,
        _Qu,
        _SAC,
        _SMES,
        _MRAIS,
        _BBOFE,
        _MRA,
        _TWIS,
        _FRT,
        _AMKESC,
        _SMKESC,
        _SC,
        _DDBESC,
        _KMSKA,
        _FCE,
        _ESMA,
        _MC,
        _PPC,
    ],
    [
        0,
        0,
        4,
        1,
        1,
        1,
        0,
        () => FilterCriteria,
        0,
        4,
        0,
        0,
        0,
        () => DestinationConfig,
        64 | 0,
        64 | 0,
        () => SourceAccessConfigurations,
        () => SelfManagedEventSource,
        1,
        2,
        1,
        1,
        64 | 0,
        () => AmazonManagedKafkaEventSourceConfig,
        () => SelfManagedKafkaEventSourceConfig,
        () => ScalingConfig,
        () => DocumentDBEventSourceConfig,
        0,
        () => FilterCriteriaError,
        0,
        () => EventSourceMappingMetricsConfig,
        () => ProvisionedPollerConfig,
    ],
];
var EventSourceMappingMetricsConfig = [3, n0, _ESMMC, 0, [_Me], [64 | 0]];
var FileSystemConfig = [3, n0, _FSCi, 0, [_Arn, _LMP], [0, 0]];
var Filter = [3, n0, _F, 0, [_Pa], [0]];
var FilterCriteria = [3, n0, _FCi, 0, [_Fi], [() => FilterList]];
var FilterCriteriaError = [3, n0, _FCE, 0, [_EC, _M], [0, 0]];
var FunctionCode = [
    3,
    n0,
    _FCu,
    0,
    [_ZF, _SB, _SK, _SOV, _IU, _SKMSKA],
    [[() => _Blob, 0], 0, 0, 0, 0, 0],
];
var FunctionCodeLocation = [
    3,
    n0,
    _FCL,
    0,
    [_RT, _Lo, _IU, _RIU, _SKMSKA],
    [0, 0, 0, 0, 0],
];
var FunctionConfiguration = [
    3,
    n0,
    _FCun,
    0,
    [
        _FN,
        _FA,
        _R,
        _Ro,
        _H,
        _CS,
        _D,
        _Ti,
        _MS,
        _LM,
        _CSo,
        _Ve,
        _VC,
        _DLC,
        _En,
        _KMSKA,
        _TC,
        _MAa,
        _RI,
        _L,
        _St,
        _SR,
        _SRCt,
        _LUS,
        _LUSR,
        _LUSRC,
        _FSC,
        _PT,
        _ICR,
        _SPVAi,
        _SJA,
        _Ar,
        _ES,
        _SSn,
        _RVC,
        _LC,
    ],
    [
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        1,
        1,
        0,
        0,
        0,
        () => VpcConfigResponse,
        () => DeadLetterConfig,
        [() => EnvironmentResponse, 0],
        0,
        () => TracingConfigResponse,
        0,
        0,
        () => LayersReferenceList,
        0,
        0,
        0,
        0,
        0,
        0,
        () => FileSystemConfigList,
        0,
        [() => ImageConfigResponse, 0],
        0,
        0,
        64 | 0,
        () => EphemeralStorage,
        () => SnapStartResponse,
        [() => RuntimeVersionConfig, 0],
        () => LoggingConfig,
    ],
];
var FunctionEventInvokeConfig = [
    3,
    n0,
    _FEIC,
    0,
    [_LM, _FA, _MRA, _MEAIS, _DC],
    [4, 0, 1, 1, () => DestinationConfig],
];
var FunctionUrlConfig = [
    3,
    n0,
    _FUC,
    0,
    [_FU, _FA, _CT, _LMT, _Co, _AT, _IM],
    [0, 0, 0, 0, () => Cors, 0, 0],
];
var GetAccountSettingsRequest = [3, n0, _GASR, 0, [], []];
var GetAccountSettingsResponse = [
    3,
    n0,
    _GASRe,
    0,
    [_AL, _AU],
    [() => AccountLimit, () => AccountUsage],
];
var GetAliasRequest = [
    3,
    n0,
    _GAR,
    0,
    [_FN, _N],
    [
        [0, 1],
        [0, 1],
    ],
];
var GetCodeSigningConfigRequest = [3, n0, _GCSCR, 0, [_CSCA], [[0, 1]]];
var GetCodeSigningConfigResponse = [3, n0, _GCSCRe, 0, [_CSC], [() => CodeSigningConfig]];
var GetEventSourceMappingRequest = [3, n0, _GESMR, 0, [_UUID], [[0, 1]]];
var GetFunctionCodeSigningConfigRequest = [3, n0, _GFCSCR, 0, [_FN], [[0, 1]]];
var GetFunctionCodeSigningConfigResponse = [3, n0, _GFCSCRe, 0, [_CSCA, _FN], [0, 0]];
var GetFunctionConcurrencyRequest = [3, n0, _GFCR, 0, [_FN], [[0, 1]]];
var GetFunctionConcurrencyResponse = [3, n0, _GFCRe, 0, [_RCE], [1]];
var GetFunctionConfigurationRequest = [
    3,
    n0,
    _GFCRet,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetFunctionEventInvokeConfigRequest = [
    3,
    n0,
    _GFEICR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetFunctionRecursionConfigRequest = [3, n0, _GFRCR, 0, [_FN], [[0, 1]]];
var GetFunctionRecursionConfigResponse = [3, n0, _GFRCRe, 0, [_RL], [0]];
var GetFunctionRequest = [
    3,
    n0,
    _GFR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetFunctionResponse = [
    3,
    n0,
    _GFRe,
    0,
    [_Con, _Cod, _Ta, _TE, _C],
    [[() => FunctionConfiguration, 0], () => FunctionCodeLocation, 128 | 0, () => TagsError, () => Concurrency],
];
var GetFunctionUrlConfigRequest = [
    3,
    n0,
    _GFUCR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetFunctionUrlConfigResponse = [
    3,
    n0,
    _GFUCRe,
    0,
    [_FU, _FA, _AT, _Co, _CT, _LMT, _IM],
    [0, 0, 0, () => Cors, 0, 0, 0],
];
var GetLayerVersionByArnRequest = [
    3,
    n0,
    _GLVBAR,
    0,
    [_Arn],
    [
        [
            0,
            {
                [_hQ]: _Arn,
            },
        ],
    ],
];
var GetLayerVersionPolicyRequest = [
    3,
    n0,
    _GLVPR,
    0,
    [_LN, _VN],
    [
        [0, 1],
        [1, 1],
    ],
];
var GetLayerVersionPolicyResponse = [3, n0, _GLVPRe, 0, [_Po, _RI], [0, 0]];
var GetLayerVersionRequest = [
    3,
    n0,
    _GLVR,
    0,
    [_LN, _VN],
    [
        [0, 1],
        [1, 1],
    ],
];
var GetLayerVersionResponse = [
    3,
    n0,
    _GLVRe,
    0,
    [_Cont, _LA, _LVA, _D, _CD, _Ve, _CR, _LI, _CA],
    [() => LayerVersionContentOutput, 0, 0, 0, 0, 1, 64 | 0, 0, 64 | 0],
];
var GetPolicyRequest = [
    3,
    n0,
    _GPR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetPolicyResponse = [3, n0, _GPRe, 0, [_Po, _RI], [0, 0]];
var GetProvisionedConcurrencyConfigRequest = [
    3,
    n0,
    _GPCCR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetProvisionedConcurrencyConfigResponse = [
    3,
    n0,
    _GPCCRe,
    0,
    [_RPCE, _APCE, _APCEl, _Sta, _SRt, _LM],
    [1, 1, 1, 0, 0, 0],
];
var GetRuntimeManagementConfigRequest = [
    3,
    n0,
    _GRMCR,
    0,
    [_FN, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var GetRuntimeManagementConfigResponse = [
    3,
    n0,
    _GRMCRe,
    0,
    [_URO, _RVA, _FA],
    [0, 0, 0],
];
var ImageConfig = [3, n0, _IC, 0, [_EP, _Com, _WD], [64 | 0, 64 | 0, 0]];
var ImageConfigError = [3, n0, _ICE, 0, [_EC, _M], [0, [() => SensitiveString, 0]]];
var ImageConfigResponse = [
    3,
    n0,
    _ICR,
    0,
    [_IC, _Er],
    [() => ImageConfig, [() => ImageConfigError, 0]],
];
var InvalidCodeSignatureException = [
    -3,
    n0,
    _ICSE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidCodeSignatureException, InvalidCodeSignatureException$1);
var InvalidParameterValueException = [
    -3,
    n0,
    _IPVE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidParameterValueException, InvalidParameterValueException$1);
var InvalidRequestContentException = [
    -3,
    n0,
    _IRCE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidRequestContentException, InvalidRequestContentException$1);
var InvalidRuntimeException = [
    -3,
    n0,
    _IRE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidRuntimeException, InvalidRuntimeException$1);
var InvalidSecurityGroupIDException = [
    -3,
    n0,
    _ISGIDE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidSecurityGroupIDException, InvalidSecurityGroupIDException$1);
var InvalidSubnetIDException = [
    -3,
    n0,
    _ISIDE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidSubnetIDException, InvalidSubnetIDException$1);
var InvalidZipFileException = [
    -3,
    n0,
    _IZFE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(InvalidZipFileException, InvalidZipFileException$1);
var InvocationRequest = [
    3,
    n0,
    _IR,
    0,
    [_FN, _IT, _LT, _CC, _Pay, _Q],
    [
        [0, 1],
        [
            0,
            {
                [_hH]: _XAIT,
            },
        ],
        [
            0,
            {
                [_hH]: _XALT,
            },
        ],
        [
            0,
            {
                [_hH]: _XACC,
            },
        ],
        [() => _Blob, 16],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
    ],
];
var InvocationResponse = [
    3,
    n0,
    _IRn,
    0,
    [_SCt, _FE, _LR, _Pay, _EV],
    [
        [1, 32],
        [
            0,
            {
                [_hH]: _XAFE,
            },
        ],
        [
            0,
            {
                [_hH]: _XALR,
            },
        ],
        [() => _Blob, 16],
        [
            0,
            {
                [_hH]: _XAEV,
            },
        ],
    ],
];
var InvokeAsyncRequest = [
    3,
    n0,
    _IAR,
    0,
    [_FN, _IA],
    [
        [0, 1],
        [() => BlobStream, 16],
    ],
];
var InvokeAsyncResponse = [3, n0, _IARn, 0, [_Sta], [[1, 32]]];
var InvokeResponseStreamUpdate = [
    3,
    n0,
    _IRSU,
    0,
    [_Pay],
    [
        [
            () => _Blob,
            {
                [_eP]: 1,
            },
        ],
    ],
];
var InvokeWithResponseStreamCompleteEvent = [
    3,
    n0,
    _IWRSCE,
    0,
    [_EC, _ED, _LR],
    [0, 0, 0],
];
var InvokeWithResponseStreamRequest = [
    3,
    n0,
    _IWRSR,
    0,
    [_FN, _IT, _LT, _CC, _Q, _Pay],
    [
        [0, 1],
        [
            0,
            {
                [_hH]: _XAIT,
            },
        ],
        [
            0,
            {
                [_hH]: _XALT,
            },
        ],
        [
            0,
            {
                [_hH]: _XACC,
            },
        ],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        [() => _Blob, 16],
    ],
];
var InvokeWithResponseStreamResponse = [
    3,
    n0,
    _IWRSRn,
    0,
    [_SCt, _EV, _ESv, _RSCT],
    [
        [1, 32],
        [
            0,
            {
                [_hH]: _XAEV,
            },
        ],
        [() => InvokeWithResponseStreamResponseEvent, 16],
        [
            0,
            {
                [_hH]: _CT_,
            },
        ],
    ],
];
var KafkaSchemaRegistryAccessConfig = [3, n0, _KSRAC, 0, [_T, _URI], [0, 0]];
var KafkaSchemaRegistryConfig = [
    3,
    n0,
    _KSRC,
    0,
    [_SRURI, _ERF, _ACc, _SVC],
    [0, 0, () => KafkaSchemaRegistryAccessConfigList, () => KafkaSchemaValidationConfigList],
];
var KafkaSchemaValidationConfig = [3, n0, _KSVC, 0, [_At], [0]];
var KMSAccessDeniedException = [
    -3,
    n0,
    _KMSADE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(KMSAccessDeniedException, KMSAccessDeniedException$1);
var KMSDisabledException = [
    -3,
    n0,
    _KMSDE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(KMSDisabledException, KMSDisabledException$1);
var KMSInvalidStateException = [
    -3,
    n0,
    _KMSISE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(KMSInvalidStateException, KMSInvalidStateException$1);
var KMSNotFoundException = [
    -3,
    n0,
    _KMSNFE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(KMSNotFoundException, KMSNotFoundException$1);
var Layer = [3, n0, _La, 0, [_Arn, _CS, _SPVAi, _SJA], [0, 1, 0, 0]];
var LayersListItem = [
    3,
    n0,
    _LLI,
    0,
    [_LN, _LA, _LMV],
    [0, 0, () => LayerVersionsListItem],
];
var LayerVersionContentInput = [
    3,
    n0,
    _LVCI,
    0,
    [_SB, _SK, _SOV, _ZF],
    [0, 0, 0, [() => _Blob, 0]],
];
var LayerVersionContentOutput = [
    3,
    n0,
    _LVCO,
    0,
    [_Lo, _CSo, _CS, _SPVAi, _SJA],
    [0, 0, 1, 0, 0],
];
var LayerVersionsListItem = [
    3,
    n0,
    _LVLI,
    0,
    [_LVA, _Ve, _D, _CD, _CR, _LI, _CA],
    [0, 1, 0, 0, 64 | 0, 0, 64 | 0],
];
var ListAliasesRequest = [
    3,
    n0,
    _LAR,
    0,
    [_FN, _FV, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _FV,
            },
        ],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListAliasesResponse = [3, n0, _LARi, 0, [_NM, _Al], [0, () => AliasList]];
var ListCodeSigningConfigsRequest = [
    3,
    n0,
    _LCSCR,
    0,
    [_Ma, _MI],
    [
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListCodeSigningConfigsResponse = [
    3,
    n0,
    _LCSCRi,
    0,
    [_NM, _CSCo],
    [0, () => CodeSigningConfigList],
];
var ListEventSourceMappingsRequest = [
    3,
    n0,
    _LESMR,
    0,
    [_ESA, _FN, _Ma, _MI],
    [
        [
            0,
            {
                [_hQ]: _ESA,
            },
        ],
        [
            0,
            {
                [_hQ]: _FN,
            },
        ],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListEventSourceMappingsResponse = [
    3,
    n0,
    _LESMRi,
    0,
    [_NM, _ESM],
    [0, () => EventSourceMappingsList],
];
var ListFunctionEventInvokeConfigsRequest = [
    3,
    n0,
    _LFEICR,
    0,
    [_FN, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListFunctionEventInvokeConfigsResponse = [
    3,
    n0,
    _LFEICRi,
    0,
    [_FEICu, _NM],
    [() => FunctionEventInvokeConfigList, 0],
];
var ListFunctionsByCodeSigningConfigRequest = [
    3,
    n0,
    _LFBCSCR,
    0,
    [_CSCA, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListFunctionsByCodeSigningConfigResponse = [
    3,
    n0,
    _LFBCSCRi,
    0,
    [_NM, _FAu],
    [0, 64 | 0],
];
var ListFunctionsRequest = [
    3,
    n0,
    _LFR,
    0,
    [_MR, _FV, _Ma, _MI],
    [
        [
            0,
            {
                [_hQ]: _MR,
            },
        ],
        [
            0,
            {
                [_hQ]: _FV,
            },
        ],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListFunctionsResponse = [3, n0, _LFRi, 0, [_NM, _Fu], [0, [() => FunctionList, 0]]];
var ListFunctionUrlConfigsRequest = [
    3,
    n0,
    _LFUCR,
    0,
    [_FN, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListFunctionUrlConfigsResponse = [
    3,
    n0,
    _LFUCRi,
    0,
    [_FUCu, _NM],
    [() => FunctionUrlConfigList, 0],
];
var ListLayersRequest = [
    3,
    n0,
    _LLR,
    0,
    [_CRo, _Ma, _MI, _CAo],
    [
        [
            0,
            {
                [_hQ]: _CRo,
            },
        ],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
        [
            0,
            {
                [_hQ]: _CAo,
            },
        ],
    ],
];
var ListLayersResponse = [3, n0, _LLRi, 0, [_NM, _L], [0, () => LayersList]];
var ListLayerVersionsRequest = [
    3,
    n0,
    _LLVR,
    0,
    [_CRo, _LN, _Ma, _MI, _CAo],
    [
        [
            0,
            {
                [_hQ]: _CRo,
            },
        ],
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
        [
            0,
            {
                [_hQ]: _CAo,
            },
        ],
    ],
];
var ListLayerVersionsResponse = [
    3,
    n0,
    _LLVRi,
    0,
    [_NM, _LV],
    [0, () => LayerVersionsList],
];
var ListProvisionedConcurrencyConfigsRequest = [
    3,
    n0,
    _LPCCR,
    0,
    [_FN, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListProvisionedConcurrencyConfigsResponse = [
    3,
    n0,
    _LPCCRi,
    0,
    [_PCC, _NM],
    [() => ProvisionedConcurrencyConfigList, 0],
];
var ListTagsRequest = [3, n0, _LTR, 0, [_Re], [[0, 1]]];
var ListTagsResponse = [3, n0, _LTRi, 0, [_Ta], [128 | 0]];
var ListVersionsByFunctionRequest = [
    3,
    n0,
    _LVBFR,
    0,
    [_FN, _Ma, _MI],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Ma,
            },
        ],
        [
            1,
            {
                [_hQ]: _MI,
            },
        ],
    ],
];
var ListVersionsByFunctionResponse = [
    3,
    n0,
    _LVBFRi,
    0,
    [_NM, _Ver],
    [0, [() => FunctionList, 0]],
];
var LoggingConfig = [3, n0, _LC, 0, [_LF, _ALL, _SLL, _LG], [0, 0, 0, 0]];
var OnFailure = [3, n0, _OF, 0, [_De], [0]];
var OnSuccess = [3, n0, _OS, 0, [_De], [0]];
var PolicyLengthExceededException = [
    -3,
    n0,
    _PLEE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(PolicyLengthExceededException, PolicyLengthExceededException$1);
var PreconditionFailedException = [
    -3,
    n0,
    _PFE,
    {
        [_e]: _c,
        [_hE]: 412,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(PreconditionFailedException, PreconditionFailedException$1);
var ProvisionedConcurrencyConfigListItem = [
    3,
    n0,
    _PCCLI,
    0,
    [_FA, _RPCE, _APCE, _APCEl, _Sta, _SRt, _LM],
    [0, 1, 1, 1, 0, 0, 0],
];
var ProvisionedConcurrencyConfigNotFoundException = [
    -3,
    n0,
    _PCCNFE,
    {
        [_e]: _c,
        [_hE]: 404,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ProvisionedConcurrencyConfigNotFoundException, ProvisionedConcurrencyConfigNotFoundException$1);
var ProvisionedPollerConfig = [3, n0, _PPC, 0, [_MP, _MPa], [1, 1]];
var PublishLayerVersionRequest = [
    3,
    n0,
    _PLVR,
    0,
    [_LN, _D, _Cont, _CR, _LI, _CA],
    [[0, 1], 0, [() => LayerVersionContentInput, 0], 64 | 0, 0, 64 | 0],
];
var PublishLayerVersionResponse = [
    3,
    n0,
    _PLVRu,
    0,
    [_Cont, _LA, _LVA, _D, _CD, _Ve, _CR, _LI, _CA],
    [() => LayerVersionContentOutput, 0, 0, 0, 0, 1, 64 | 0, 0, 64 | 0],
];
var PublishVersionRequest = [3, n0, _PVR, 0, [_FN, _CSo, _D, _RI], [[0, 1], 0, 0, 0]];
var PutFunctionCodeSigningConfigRequest = [3, n0, _PFCSCR, 0, [_CSCA, _FN], [0, [0, 1]]];
var PutFunctionCodeSigningConfigResponse = [3, n0, _PFCSCRu, 0, [_CSCA, _FN], [0, 0]];
var PutFunctionConcurrencyRequest = [3, n0, _PFCR, 0, [_FN, _RCE], [[0, 1], 1]];
var PutFunctionEventInvokeConfigRequest = [
    3,
    n0,
    _PFEICR,
    0,
    [_FN, _Q, _MRA, _MEAIS, _DC],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        1,
        1,
        () => DestinationConfig,
    ],
];
var PutFunctionRecursionConfigRequest = [3, n0, _PFRCR, 0, [_FN, _RL], [[0, 1], 0]];
var PutFunctionRecursionConfigResponse = [3, n0, _PFRCRu, 0, [_RL], [0]];
var PutProvisionedConcurrencyConfigRequest = [
    3,
    n0,
    _PPCCR,
    0,
    [_FN, _Q, _PCE],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        1,
    ],
];
var PutProvisionedConcurrencyConfigResponse = [
    3,
    n0,
    _PPCCRu,
    0,
    [_RPCE, _APCE, _APCEl, _Sta, _SRt, _LM],
    [1, 1, 1, 0, 0, 0],
];
var PutRuntimeManagementConfigRequest = [
    3,
    n0,
    _PRMCR,
    0,
    [_FN, _Q, _URO, _RVA],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        0,
        0,
    ],
];
var PutRuntimeManagementConfigResponse = [
    3,
    n0,
    _PRMCRu,
    0,
    [_URO, _FA, _RVA],
    [0, 0, 0],
];
var RecursiveInvocationException = [
    -3,
    n0,
    _RIE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(RecursiveInvocationException, RecursiveInvocationException$1);
var RemoveLayerVersionPermissionRequest = [
    3,
    n0,
    _RLVPR,
    0,
    [_LN, _VN, _SI, _RI],
    [
        [0, 1],
        [1, 1],
        [0, 1],
        [
            0,
            {
                [_hQ]: _RI,
            },
        ],
    ],
];
var RemovePermissionRequest = [
    3,
    n0,
    _RPR,
    0,
    [_FN, _SI, _Q, _RI],
    [
        [0, 1],
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        [
            0,
            {
                [_hQ]: _RI,
            },
        ],
    ],
];
var RequestTooLargeException = [
    -3,
    n0,
    _RTLE,
    {
        [_e]: _c,
        [_hE]: 413,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(RequestTooLargeException, RequestTooLargeException$1);
var ResourceConflictException = [
    -3,
    n0,
    _RCEe,
    {
        [_e]: _c,
        [_hE]: 409,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ResourceConflictException, ResourceConflictException$1);
var ResourceInUseException = [
    -3,
    n0,
    _RIUE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ResourceInUseException, ResourceInUseException$1);
var ResourceNotFoundException = [
    -3,
    n0,
    _RNFE,
    {
        [_e]: _c,
        [_hE]: 404,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
var ResourceNotReadyException = [
    -3,
    n0,
    _RNRE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ResourceNotReadyException, ResourceNotReadyException$1);
var RuntimeVersionConfig = [
    3,
    n0,
    _RVC,
    0,
    [_RVA, _Er],
    [0, [() => RuntimeVersionError, 0]],
];
var RuntimeVersionError = [3, n0, _RVE, 0, [_EC, _M], [0, [() => SensitiveString, 0]]];
var ScalingConfig = [3, n0, _SC, 0, [_MCa], [1]];
var SelfManagedEventSource = [3, n0, _SMES, 0, [_End], [[2, n0, _End, 0, 0, 64 | 0]]];
var SelfManagedKafkaEventSourceConfig = [
    3,
    n0,
    _SMKESC,
    0,
    [_CGI, _SRC],
    [0, () => KafkaSchemaRegistryConfig],
];
var SerializedRequestEntityTooLargeException = [
    -3,
    n0,
    _SRETLE,
    {
        [_e]: _c,
        [_hE]: 413,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(SerializedRequestEntityTooLargeException, SerializedRequestEntityTooLargeException$1);
var ServiceException = [
    -3,
    n0,
    _SE,
    {
        [_e]: _se,
        [_hE]: 500,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(ServiceException, ServiceException$1);
var SnapStart = [3, n0, _SSn, 0, [_AOp], [0]];
var SnapStartException = [
    -3,
    n0,
    _SSE,
    {
        [_e]: _c,
        [_hE]: 400,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(SnapStartException, SnapStartException$1);
var SnapStartNotReadyException = [
    -3,
    n0,
    _SSNRE,
    {
        [_e]: _c,
        [_hE]: 409,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(SnapStartNotReadyException, SnapStartNotReadyException$1);
var SnapStartResponse = [3, n0, _SSR, 0, [_AOp, _OSp], [0, 0]];
var SnapStartTimeoutException = [
    -3,
    n0,
    _SSTE,
    {
        [_e]: _c,
        [_hE]: 408,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(SnapStartTimeoutException, SnapStartTimeoutException$1);
var SourceAccessConfiguration = [3, n0, _SACo, 0, [_T, _URI], [0, 0]];
var SubnetIPAddressLimitReachedException = [
    -3,
    n0,
    _SIPALRE,
    {
        [_e]: _se,
        [_hE]: 502,
    },
    [_T, _M],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(SubnetIPAddressLimitReachedException, SubnetIPAddressLimitReachedException$1);
var TagResourceRequest = [3, n0, _TRR, 0, [_Re, _Ta], [[0, 1], 128 | 0]];
var TagsError = [3, n0, _TE, 0, [_EC, _M], [0, 0]];
var TooManyRequestsException = [
    -3,
    n0,
    _TMRE,
    {
        [_e]: _c,
        [_hE]: 429,
    },
    [_rAS, _T, _m, _Rea],
    [
        [
            0,
            {
                [_hH]: _RA,
            },
        ],
        0,
        0,
        0,
    ],
];
schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
var TracingConfig = [3, n0, _TC, 0, [_Mo], [0]];
var TracingConfigResponse = [3, n0, _TCR, 0, [_Mo], [0]];
var UnsupportedMediaTypeException = [
    -3,
    n0,
    _UMTE,
    {
        [_e]: _c,
        [_hE]: 415,
    },
    [_T, _m],
    [0, 0],
];
schema.TypeRegistry.for(n0).registerError(UnsupportedMediaTypeException, UnsupportedMediaTypeException$1);
var UntagResourceRequest = [
    3,
    n0,
    _URR,
    0,
    [_Re, _TK],
    [
        [0, 1],
        [
            64 | 0,
            {
                [_hQ]: _tK,
            },
        ],
    ],
];
var UpdateAliasRequest = [
    3,
    n0,
    _UAR,
    0,
    [_FN, _N, _FV, _D, _RC, _RI],
    [[0, 1], [0, 1], 0, 0, () => AliasRoutingConfiguration, 0],
];
var UpdateCodeSigningConfigRequest = [
    3,
    n0,
    _UCSCR,
    0,
    [_CSCA, _D, _AP, _CSP],
    [[0, 1], 0, () => AllowedPublishers, () => CodeSigningPolicies],
];
var UpdateCodeSigningConfigResponse = [
    3,
    n0,
    _UCSCRp,
    0,
    [_CSC],
    [() => CodeSigningConfig],
];
var UpdateEventSourceMappingRequest = [
    3,
    n0,
    _UESMR,
    0,
    [
        _UUID,
        _FN,
        _E,
        _BSa,
        _FCi,
        _MBWIS,
        _DC,
        _MRAIS,
        _BBOFE,
        _MRA,
        _PF,
        _SAC,
        _TWIS,
        _FRT,
        _SC,
        _AMKESC,
        _SMKESC,
        _DDBESC,
        _KMSKA,
        _MC,
        _PPC,
    ],
    [
        [0, 1],
        0,
        2,
        1,
        () => FilterCriteria,
        1,
        () => DestinationConfig,
        1,
        2,
        1,
        1,
        () => SourceAccessConfigurations,
        1,
        64 | 0,
        () => ScalingConfig,
        () => AmazonManagedKafkaEventSourceConfig,
        () => SelfManagedKafkaEventSourceConfig,
        () => DocumentDBEventSourceConfig,
        0,
        () => EventSourceMappingMetricsConfig,
        () => ProvisionedPollerConfig,
    ],
];
var UpdateFunctionCodeRequest = [
    3,
    n0,
    _UFCR,
    0,
    [_FN, _ZF, _SB, _SK, _SOV, _IU, _Pu, _DR, _RI, _Ar, _SKMSKA],
    [[0, 1], [() => _Blob, 0], 0, 0, 0, 0, 2, 2, 0, 64 | 0, 0],
];
var UpdateFunctionConfigurationRequest = [
    3,
    n0,
    _UFCRp,
    0,
    [_FN, _Ro, _H, _D, _Ti, _MS, _VC, _En, _R, _DLC, _KMSKA, _TC, _RI, _L, _FSC, _IC, _ES, _SSn, _LC],
    [
        [0, 1],
        0,
        0,
        0,
        1,
        1,
        () => VpcConfig,
        [() => Environment, 0],
        0,
        () => DeadLetterConfig,
        0,
        () => TracingConfig,
        0,
        64 | 0,
        () => FileSystemConfigList,
        () => ImageConfig,
        () => EphemeralStorage,
        () => SnapStart,
        () => LoggingConfig,
    ],
];
var UpdateFunctionEventInvokeConfigRequest = [
    3,
    n0,
    _UFEICR,
    0,
    [_FN, _Q, _MRA, _MEAIS, _DC],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        1,
        1,
        () => DestinationConfig,
    ],
];
var UpdateFunctionUrlConfigRequest = [
    3,
    n0,
    _UFUCR,
    0,
    [_FN, _Q, _AT, _Co, _IM],
    [
        [0, 1],
        [
            0,
            {
                [_hQ]: _Q,
            },
        ],
        0,
        () => Cors,
        0,
    ],
];
var UpdateFunctionUrlConfigResponse = [
    3,
    n0,
    _UFUCRp,
    0,
    [_FU, _FA, _AT, _Co, _CT, _LMT, _IM],
    [0, 0, 0, () => Cors, 0, 0, 0],
];
var VpcConfig = [3, n0, _VC, 0, [_SIu, _SGI, _IAFDS], [64 | 0, 64 | 0, 2]];
var VpcConfigResponse = [
    3,
    n0,
    _VCR,
    0,
    [_SIu, _SGI, _VI, _IAFDS],
    [64 | 0, 64 | 0, 0, 2],
];
var __Unit = "unit";
var LambdaServiceException = [-3, _sm, "LambdaServiceException", 0, [], []];
schema.TypeRegistry.for(_sm).registerError(LambdaServiceException, LambdaServiceException$1);
var AliasList = [1, n0, _ALl, 0, () => AliasConfiguration];
var CodeSigningConfigList = [1, n0, _CSCL, 0, () => CodeSigningConfig];
var EventSourceMappingsList = [1, n0, _ESML, 0, () => EventSourceMappingConfiguration];
var FileSystemConfigList = [1, n0, _FSCL, 0, () => FileSystemConfig];
var FilterList = [1, n0, _FL, 0, () => Filter];
var FunctionEventInvokeConfigList = [1, n0, _FEICL, 0, () => FunctionEventInvokeConfig];
var FunctionList = [1, n0, _FLu, 0, [() => FunctionConfiguration, 0]];
var FunctionUrlConfigList = [1, n0, _FUCL, 0, () => FunctionUrlConfig];
var KafkaSchemaRegistryAccessConfigList = [
    1,
    n0,
    _KSRACL,
    0,
    () => KafkaSchemaRegistryAccessConfig,
];
var KafkaSchemaValidationConfigList = [1, n0, _KSVCL, 0, () => KafkaSchemaValidationConfig];
var LayersList = [1, n0, _LL, 0, () => LayersListItem];
var LayersReferenceList = [1, n0, _LRL, 0, () => Layer];
var LayerVersionsList = [1, n0, _LVL, 0, () => LayerVersionsListItem];
var ProvisionedConcurrencyConfigList = [
    1,
    n0,
    _PCCL,
    0,
    () => ProvisionedConcurrencyConfigListItem,
];
var SourceAccessConfigurations = [1, n0, _SAC, 0, () => SourceAccessConfiguration];
var EnvironmentVariables = [
    2,
    n0,
    _EVn,
    8,
    [() => EnvironmentVariableName, 0],
    [() => EnvironmentVariableValue, 0],
];
var InvokeWithResponseStreamResponseEvent = [
    3,
    n0,
    _IWRSRE,
    {
        [_s]: 1,
    },
    [_PC, _ICn],
    [[() => InvokeResponseStreamUpdate, 0], () => InvokeWithResponseStreamCompleteEvent],
];
var AddLayerVersionPermission = [
    9,
    n0,
    _ALVP,
    {
        [_h]: ["POST", "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy", 201],
    },
    () => AddLayerVersionPermissionRequest,
    () => AddLayerVersionPermissionResponse,
];
var AddPermission = [
    9,
    n0,
    _APd,
    {
        [_h]: ["POST", "/2015-03-31/functions/{FunctionName}/policy", 201],
    },
    () => AddPermissionRequest,
    () => AddPermissionResponse,
];
var CreateAlias = [
    9,
    n0,
    _CAr,
    {
        [_h]: ["POST", "/2015-03-31/functions/{FunctionName}/aliases", 201],
    },
    () => CreateAliasRequest,
    () => AliasConfiguration,
];
var CreateCodeSigningConfig = [
    9,
    n0,
    _CCSC,
    {
        [_h]: ["POST", "/2020-04-22/code-signing-configs", 201],
    },
    () => CreateCodeSigningConfigRequest,
    () => CreateCodeSigningConfigResponse,
];
var CreateEventSourceMapping = [
    9,
    n0,
    _CESM,
    {
        [_h]: ["POST", "/2015-03-31/event-source-mappings", 202],
    },
    () => CreateEventSourceMappingRequest,
    () => EventSourceMappingConfiguration,
];
var CreateFunction = [
    9,
    n0,
    _CF,
    {
        [_h]: ["POST", "/2015-03-31/functions", 201],
    },
    () => CreateFunctionRequest,
    () => FunctionConfiguration,
];
var CreateFunctionUrlConfig = [
    9,
    n0,
    _CFUC,
    {
        [_h]: ["POST", "/2021-10-31/functions/{FunctionName}/url", 201],
    },
    () => CreateFunctionUrlConfigRequest,
    () => CreateFunctionUrlConfigResponse,
];
var DeleteAlias = [
    9,
    n0,
    _DA,
    {
        [_h]: ["DELETE", "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 204],
    },
    () => DeleteAliasRequest,
    () => __Unit,
];
var DeleteCodeSigningConfig = [
    9,
    n0,
    _DCSC,
    {
        [_h]: ["DELETE", "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 204],
    },
    () => DeleteCodeSigningConfigRequest,
    () => DeleteCodeSigningConfigResponse,
];
var DeleteEventSourceMapping = [
    9,
    n0,
    _DESM,
    {
        [_h]: ["DELETE", "/2015-03-31/event-source-mappings/{UUID}", 202],
    },
    () => DeleteEventSourceMappingRequest,
    () => EventSourceMappingConfiguration,
];
var DeleteFunction = [
    9,
    n0,
    _DF,
    {
        [_h]: ["DELETE", "/2015-03-31/functions/{FunctionName}", 204],
    },
    () => DeleteFunctionRequest,
    () => __Unit,
];
var DeleteFunctionCodeSigningConfig = [
    9,
    n0,
    _DFCSC,
    {
        [_h]: ["DELETE", "/2020-06-30/functions/{FunctionName}/code-signing-config", 204],
    },
    () => DeleteFunctionCodeSigningConfigRequest,
    () => __Unit,
];
var DeleteFunctionConcurrency = [
    9,
    n0,
    _DFC,
    {
        [_h]: ["DELETE", "/2017-10-31/functions/{FunctionName}/concurrency", 204],
    },
    () => DeleteFunctionConcurrencyRequest,
    () => __Unit,
];
var DeleteFunctionEventInvokeConfig = [
    9,
    n0,
    _DFEIC,
    {
        [_h]: ["DELETE", "/2019-09-25/functions/{FunctionName}/event-invoke-config", 204],
    },
    () => DeleteFunctionEventInvokeConfigRequest,
    () => __Unit,
];
var DeleteFunctionUrlConfig = [
    9,
    n0,
    _DFUC,
    {
        [_h]: ["DELETE", "/2021-10-31/functions/{FunctionName}/url", 204],
    },
    () => DeleteFunctionUrlConfigRequest,
    () => __Unit,
];
var DeleteLayerVersion = [
    9,
    n0,
    _DLV,
    {
        [_h]: ["DELETE", "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}", 204],
    },
    () => DeleteLayerVersionRequest,
    () => __Unit,
];
var DeleteProvisionedConcurrencyConfig = [
    9,
    n0,
    _DPCC,
    {
        [_h]: ["DELETE", "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 204],
    },
    () => DeleteProvisionedConcurrencyConfigRequest,
    () => __Unit,
];
var GetAccountSettings = [
    9,
    n0,
    _GAS,
    {
        [_h]: ["GET", "/2016-08-19/account-settings", 200],
    },
    () => GetAccountSettingsRequest,
    () => GetAccountSettingsResponse,
];
var GetAlias = [
    9,
    n0,
    _GA,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 200],
    },
    () => GetAliasRequest,
    () => AliasConfiguration,
];
var GetCodeSigningConfig = [
    9,
    n0,
    _GCSC,
    {
        [_h]: ["GET", "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 200],
    },
    () => GetCodeSigningConfigRequest,
    () => GetCodeSigningConfigResponse,
];
var GetEventSourceMapping = [
    9,
    n0,
    _GESM,
    {
        [_h]: ["GET", "/2015-03-31/event-source-mappings/{UUID}", 200],
    },
    () => GetEventSourceMappingRequest,
    () => EventSourceMappingConfiguration,
];
var GetFunction = [
    9,
    n0,
    _GF,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}", 200],
    },
    () => GetFunctionRequest,
    () => GetFunctionResponse,
];
var GetFunctionCodeSigningConfig = [
    9,
    n0,
    _GFCSC,
    {
        [_h]: ["GET", "/2020-06-30/functions/{FunctionName}/code-signing-config", 200],
    },
    () => GetFunctionCodeSigningConfigRequest,
    () => GetFunctionCodeSigningConfigResponse,
];
var GetFunctionConcurrency = [
    9,
    n0,
    _GFC,
    {
        [_h]: ["GET", "/2019-09-30/functions/{FunctionName}/concurrency", 200],
    },
    () => GetFunctionConcurrencyRequest,
    () => GetFunctionConcurrencyResponse,
];
var GetFunctionConfiguration = [
    9,
    n0,
    _GFCe,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}/configuration", 200],
    },
    () => GetFunctionConfigurationRequest,
    () => FunctionConfiguration,
];
var GetFunctionEventInvokeConfig = [
    9,
    n0,
    _GFEIC,
    {
        [_h]: ["GET", "/2019-09-25/functions/{FunctionName}/event-invoke-config", 200],
    },
    () => GetFunctionEventInvokeConfigRequest,
    () => FunctionEventInvokeConfig,
];
var GetFunctionRecursionConfig = [
    9,
    n0,
    _GFRC,
    {
        [_h]: ["GET", "/2024-08-31/functions/{FunctionName}/recursion-config", 200],
    },
    () => GetFunctionRecursionConfigRequest,
    () => GetFunctionRecursionConfigResponse,
];
var GetFunctionUrlConfig = [
    9,
    n0,
    _GFUC,
    {
        [_h]: ["GET", "/2021-10-31/functions/{FunctionName}/url", 200],
    },
    () => GetFunctionUrlConfigRequest,
    () => GetFunctionUrlConfigResponse,
];
var GetLayerVersion = [
    9,
    n0,
    _GLV,
    {
        [_h]: ["GET", "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}", 200],
    },
    () => GetLayerVersionRequest,
    () => GetLayerVersionResponse,
];
var GetLayerVersionByArn = [
    9,
    n0,
    _GLVBA,
    {
        [_h]: ["GET", "/2018-10-31/layers?find=LayerVersion", 200],
    },
    () => GetLayerVersionByArnRequest,
    () => GetLayerVersionResponse,
];
var GetLayerVersionPolicy = [
    9,
    n0,
    _GLVP,
    {
        [_h]: ["GET", "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy", 200],
    },
    () => GetLayerVersionPolicyRequest,
    () => GetLayerVersionPolicyResponse,
];
var GetPolicy = [
    9,
    n0,
    _GP,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}/policy", 200],
    },
    () => GetPolicyRequest,
    () => GetPolicyResponse,
];
var GetProvisionedConcurrencyConfig = [
    9,
    n0,
    _GPCC,
    {
        [_h]: ["GET", "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 200],
    },
    () => GetProvisionedConcurrencyConfigRequest,
    () => GetProvisionedConcurrencyConfigResponse,
];
var GetRuntimeManagementConfig = [
    9,
    n0,
    _GRMC,
    {
        [_h]: ["GET", "/2021-07-20/functions/{FunctionName}/runtime-management-config", 200],
    },
    () => GetRuntimeManagementConfigRequest,
    () => GetRuntimeManagementConfigResponse,
];
var Invoke = [
    9,
    n0,
    _I,
    {
        [_h]: ["POST", "/2015-03-31/functions/{FunctionName}/invocations", 200],
    },
    () => InvocationRequest,
    () => InvocationResponse,
];
var InvokeAsync = [
    9,
    n0,
    _IAn,
    {
        [_h]: ["POST", "/2014-11-13/functions/{FunctionName}/invoke-async", 202],
    },
    () => InvokeAsyncRequest,
    () => InvokeAsyncResponse,
];
var InvokeWithResponseStream = [
    9,
    n0,
    _IWRS,
    {
        [_h]: ["POST", "/2021-11-15/functions/{FunctionName}/response-streaming-invocations", 200],
    },
    () => InvokeWithResponseStreamRequest,
    () => InvokeWithResponseStreamResponse,
];
var ListAliases = [
    9,
    n0,
    _LAi,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}/aliases", 200],
    },
    () => ListAliasesRequest,
    () => ListAliasesResponse,
];
var ListCodeSigningConfigs = [
    9,
    n0,
    _LCSC,
    {
        [_h]: ["GET", "/2020-04-22/code-signing-configs", 200],
    },
    () => ListCodeSigningConfigsRequest,
    () => ListCodeSigningConfigsResponse,
];
var ListEventSourceMappings = [
    9,
    n0,
    _LESM,
    {
        [_h]: ["GET", "/2015-03-31/event-source-mappings", 200],
    },
    () => ListEventSourceMappingsRequest,
    () => ListEventSourceMappingsResponse,
];
var ListFunctionEventInvokeConfigs = [
    9,
    n0,
    _LFEIC,
    {
        [_h]: ["GET", "/2019-09-25/functions/{FunctionName}/event-invoke-config/list", 200],
    },
    () => ListFunctionEventInvokeConfigsRequest,
    () => ListFunctionEventInvokeConfigsResponse,
];
var ListFunctions = [
    9,
    n0,
    _LFi,
    {
        [_h]: ["GET", "/2015-03-31/functions", 200],
    },
    () => ListFunctionsRequest,
    () => ListFunctionsResponse,
];
var ListFunctionsByCodeSigningConfig = [
    9,
    n0,
    _LFBCSC,
    {
        [_h]: ["GET", "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions", 200],
    },
    () => ListFunctionsByCodeSigningConfigRequest,
    () => ListFunctionsByCodeSigningConfigResponse,
];
var ListFunctionUrlConfigs = [
    9,
    n0,
    _LFUC,
    {
        [_h]: ["GET", "/2021-10-31/functions/{FunctionName}/urls", 200],
    },
    () => ListFunctionUrlConfigsRequest,
    () => ListFunctionUrlConfigsResponse,
];
var ListLayers = [
    9,
    n0,
    _LLi,
    {
        [_h]: ["GET", "/2018-10-31/layers", 200],
    },
    () => ListLayersRequest,
    () => ListLayersResponse,
];
var ListLayerVersions = [
    9,
    n0,
    _LLV,
    {
        [_h]: ["GET", "/2018-10-31/layers/{LayerName}/versions", 200],
    },
    () => ListLayerVersionsRequest,
    () => ListLayerVersionsResponse,
];
var ListProvisionedConcurrencyConfigs = [
    9,
    n0,
    _LPCC,
    {
        [_h]: ["GET", "/2019-09-30/functions/{FunctionName}/provisioned-concurrency?List=ALL", 200],
    },
    () => ListProvisionedConcurrencyConfigsRequest,
    () => ListProvisionedConcurrencyConfigsResponse,
];
var ListTags = [
    9,
    n0,
    _LTi,
    {
        [_h]: ["GET", "/2017-03-31/tags/{Resource}", 200],
    },
    () => ListTagsRequest,
    () => ListTagsResponse,
];
var ListVersionsByFunction = [
    9,
    n0,
    _LVBF,
    {
        [_h]: ["GET", "/2015-03-31/functions/{FunctionName}/versions", 200],
    },
    () => ListVersionsByFunctionRequest,
    () => ListVersionsByFunctionResponse,
];
var PublishLayerVersion = [
    9,
    n0,
    _PLV,
    {
        [_h]: ["POST", "/2018-10-31/layers/{LayerName}/versions", 201],
    },
    () => PublishLayerVersionRequest,
    () => PublishLayerVersionResponse,
];
var PublishVersion = [
    9,
    n0,
    _PV,
    {
        [_h]: ["POST", "/2015-03-31/functions/{FunctionName}/versions", 201],
    },
    () => PublishVersionRequest,
    () => FunctionConfiguration,
];
var PutFunctionCodeSigningConfig = [
    9,
    n0,
    _PFCSC,
    {
        [_h]: ["PUT", "/2020-06-30/functions/{FunctionName}/code-signing-config", 200],
    },
    () => PutFunctionCodeSigningConfigRequest,
    () => PutFunctionCodeSigningConfigResponse,
];
var PutFunctionConcurrency = [
    9,
    n0,
    _PFC,
    {
        [_h]: ["PUT", "/2017-10-31/functions/{FunctionName}/concurrency", 200],
    },
    () => PutFunctionConcurrencyRequest,
    () => Concurrency,
];
var PutFunctionEventInvokeConfig = [
    9,
    n0,
    _PFEIC,
    {
        [_h]: ["PUT", "/2019-09-25/functions/{FunctionName}/event-invoke-config", 200],
    },
    () => PutFunctionEventInvokeConfigRequest,
    () => FunctionEventInvokeConfig,
];
var PutFunctionRecursionConfig = [
    9,
    n0,
    _PFRC,
    {
        [_h]: ["PUT", "/2024-08-31/functions/{FunctionName}/recursion-config", 200],
    },
    () => PutFunctionRecursionConfigRequest,
    () => PutFunctionRecursionConfigResponse,
];
var PutProvisionedConcurrencyConfig = [
    9,
    n0,
    _PPCC,
    {
        [_h]: ["PUT", "/2019-09-30/functions/{FunctionName}/provisioned-concurrency", 202],
    },
    () => PutProvisionedConcurrencyConfigRequest,
    () => PutProvisionedConcurrencyConfigResponse,
];
var PutRuntimeManagementConfig = [
    9,
    n0,
    _PRMC,
    {
        [_h]: ["PUT", "/2021-07-20/functions/{FunctionName}/runtime-management-config", 200],
    },
    () => PutRuntimeManagementConfigRequest,
    () => PutRuntimeManagementConfigResponse,
];
var RemoveLayerVersionPermission = [
    9,
    n0,
    _RLVP,
    {
        [_h]: ["DELETE", "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy/{StatementId}", 204],
    },
    () => RemoveLayerVersionPermissionRequest,
    () => __Unit,
];
var RemovePermission = [
    9,
    n0,
    _RP,
    {
        [_h]: ["DELETE", "/2015-03-31/functions/{FunctionName}/policy/{StatementId}", 204],
    },
    () => RemovePermissionRequest,
    () => __Unit,
];
var TagResource = [
    9,
    n0,
    _TR,
    {
        [_h]: ["POST", "/2017-03-31/tags/{Resource}", 204],
    },
    () => TagResourceRequest,
    () => __Unit,
];
var UntagResource = [
    9,
    n0,
    _UR,
    {
        [_h]: ["DELETE", "/2017-03-31/tags/{Resource}", 204],
    },
    () => UntagResourceRequest,
    () => __Unit,
];
var UpdateAlias = [
    9,
    n0,
    _UA,
    {
        [_h]: ["PUT", "/2015-03-31/functions/{FunctionName}/aliases/{Name}", 200],
    },
    () => UpdateAliasRequest,
    () => AliasConfiguration,
];
var UpdateCodeSigningConfig = [
    9,
    n0,
    _UCSC,
    {
        [_h]: ["PUT", "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}", 200],
    },
    () => UpdateCodeSigningConfigRequest,
    () => UpdateCodeSigningConfigResponse,
];
var UpdateEventSourceMapping = [
    9,
    n0,
    _UESM,
    {
        [_h]: ["PUT", "/2015-03-31/event-source-mappings/{UUID}", 202],
    },
    () => UpdateEventSourceMappingRequest,
    () => EventSourceMappingConfiguration,
];
var UpdateFunctionCode = [
    9,
    n0,
    _UFC,
    {
        [_h]: ["PUT", "/2015-03-31/functions/{FunctionName}/code", 200],
    },
    () => UpdateFunctionCodeRequest,
    () => FunctionConfiguration,
];
var UpdateFunctionConfiguration = [
    9,
    n0,
    _UFCp,
    {
        [_h]: ["PUT", "/2015-03-31/functions/{FunctionName}/configuration", 200],
    },
    () => UpdateFunctionConfigurationRequest,
    () => FunctionConfiguration,
];
var UpdateFunctionEventInvokeConfig = [
    9,
    n0,
    _UFEIC,
    {
        [_h]: ["POST", "/2019-09-25/functions/{FunctionName}/event-invoke-config", 200],
    },
    () => UpdateFunctionEventInvokeConfigRequest,
    () => FunctionEventInvokeConfig,
];
var UpdateFunctionUrlConfig = [
    9,
    n0,
    _UFUC,
    {
        [_h]: ["PUT", "/2021-10-31/functions/{FunctionName}/url", 200],
    },
    () => UpdateFunctionUrlConfigRequest,
    () => UpdateFunctionUrlConfigResponse,
];

class AddLayerVersionPermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "AddLayerVersionPermission", {})
    .n("LambdaClient", "AddLayerVersionPermissionCommand")
    .sc(AddLayerVersionPermission)
    .build() {
}

class AddPermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "AddPermission", {})
    .n("LambdaClient", "AddPermissionCommand")
    .sc(AddPermission)
    .build() {
}

class CreateAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "CreateAlias", {})
    .n("LambdaClient", "CreateAliasCommand")
    .sc(CreateAlias)
    .build() {
}

class CreateCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "CreateCodeSigningConfig", {})
    .n("LambdaClient", "CreateCodeSigningConfigCommand")
    .sc(CreateCodeSigningConfig)
    .build() {
}

class CreateEventSourceMappingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "CreateEventSourceMapping", {})
    .n("LambdaClient", "CreateEventSourceMappingCommand")
    .sc(CreateEventSourceMapping)
    .build() {
}

class CreateFunctionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "CreateFunction", {})
    .n("LambdaClient", "CreateFunctionCommand")
    .sc(CreateFunction)
    .build() {
}

class CreateFunctionUrlConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "CreateFunctionUrlConfig", {})
    .n("LambdaClient", "CreateFunctionUrlConfigCommand")
    .sc(CreateFunctionUrlConfig)
    .build() {
}

class DeleteAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteAlias", {})
    .n("LambdaClient", "DeleteAliasCommand")
    .sc(DeleteAlias)
    .build() {
}

class DeleteCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteCodeSigningConfig", {})
    .n("LambdaClient", "DeleteCodeSigningConfigCommand")
    .sc(DeleteCodeSigningConfig)
    .build() {
}

class DeleteEventSourceMappingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteEventSourceMapping", {})
    .n("LambdaClient", "DeleteEventSourceMappingCommand")
    .sc(DeleteEventSourceMapping)
    .build() {
}

class DeleteFunctionCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteFunctionCodeSigningConfig", {})
    .n("LambdaClient", "DeleteFunctionCodeSigningConfigCommand")
    .sc(DeleteFunctionCodeSigningConfig)
    .build() {
}

class DeleteFunctionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteFunction", {})
    .n("LambdaClient", "DeleteFunctionCommand")
    .sc(DeleteFunction)
    .build() {
}

class DeleteFunctionConcurrencyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteFunctionConcurrency", {})
    .n("LambdaClient", "DeleteFunctionConcurrencyCommand")
    .sc(DeleteFunctionConcurrency)
    .build() {
}

class DeleteFunctionEventInvokeConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteFunctionEventInvokeConfig", {})
    .n("LambdaClient", "DeleteFunctionEventInvokeConfigCommand")
    .sc(DeleteFunctionEventInvokeConfig)
    .build() {
}

class DeleteFunctionUrlConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteFunctionUrlConfig", {})
    .n("LambdaClient", "DeleteFunctionUrlConfigCommand")
    .sc(DeleteFunctionUrlConfig)
    .build() {
}

class DeleteLayerVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteLayerVersion", {})
    .n("LambdaClient", "DeleteLayerVersionCommand")
    .sc(DeleteLayerVersion)
    .build() {
}

class DeleteProvisionedConcurrencyConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "DeleteProvisionedConcurrencyConfig", {})
    .n("LambdaClient", "DeleteProvisionedConcurrencyConfigCommand")
    .sc(DeleteProvisionedConcurrencyConfig)
    .build() {
}

class GetAccountSettingsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetAccountSettings", {})
    .n("LambdaClient", "GetAccountSettingsCommand")
    .sc(GetAccountSettings)
    .build() {
}

class GetAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetAlias", {})
    .n("LambdaClient", "GetAliasCommand")
    .sc(GetAlias)
    .build() {
}

class GetCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetCodeSigningConfig", {})
    .n("LambdaClient", "GetCodeSigningConfigCommand")
    .sc(GetCodeSigningConfig)
    .build() {
}

class GetEventSourceMappingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetEventSourceMapping", {})
    .n("LambdaClient", "GetEventSourceMappingCommand")
    .sc(GetEventSourceMapping)
    .build() {
}

class GetFunctionCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionCodeSigningConfig", {})
    .n("LambdaClient", "GetFunctionCodeSigningConfigCommand")
    .sc(GetFunctionCodeSigningConfig)
    .build() {
}

class GetFunctionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunction", {})
    .n("LambdaClient", "GetFunctionCommand")
    .sc(GetFunction)
    .build() {
}

class GetFunctionConcurrencyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionConcurrency", {})
    .n("LambdaClient", "GetFunctionConcurrencyCommand")
    .sc(GetFunctionConcurrency)
    .build() {
}

class GetFunctionConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionConfiguration", {})
    .n("LambdaClient", "GetFunctionConfigurationCommand")
    .sc(GetFunctionConfiguration)
    .build() {
}

class GetFunctionEventInvokeConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionEventInvokeConfig", {})
    .n("LambdaClient", "GetFunctionEventInvokeConfigCommand")
    .sc(GetFunctionEventInvokeConfig)
    .build() {
}

class GetFunctionRecursionConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionRecursionConfig", {})
    .n("LambdaClient", "GetFunctionRecursionConfigCommand")
    .sc(GetFunctionRecursionConfig)
    .build() {
}

class GetFunctionUrlConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetFunctionUrlConfig", {})
    .n("LambdaClient", "GetFunctionUrlConfigCommand")
    .sc(GetFunctionUrlConfig)
    .build() {
}

class GetLayerVersionByArnCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetLayerVersionByArn", {})
    .n("LambdaClient", "GetLayerVersionByArnCommand")
    .sc(GetLayerVersionByArn)
    .build() {
}

class GetLayerVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetLayerVersion", {})
    .n("LambdaClient", "GetLayerVersionCommand")
    .sc(GetLayerVersion)
    .build() {
}

class GetLayerVersionPolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetLayerVersionPolicy", {})
    .n("LambdaClient", "GetLayerVersionPolicyCommand")
    .sc(GetLayerVersionPolicy)
    .build() {
}

class GetPolicyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetPolicy", {})
    .n("LambdaClient", "GetPolicyCommand")
    .sc(GetPolicy)
    .build() {
}

class GetProvisionedConcurrencyConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetProvisionedConcurrencyConfig", {})
    .n("LambdaClient", "GetProvisionedConcurrencyConfigCommand")
    .sc(GetProvisionedConcurrencyConfig)
    .build() {
}

class GetRuntimeManagementConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "GetRuntimeManagementConfig", {})
    .n("LambdaClient", "GetRuntimeManagementConfigCommand")
    .sc(GetRuntimeManagementConfig)
    .build() {
}

class InvokeAsyncCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "InvokeAsync", {})
    .n("LambdaClient", "InvokeAsyncCommand")
    .sc(InvokeAsync)
    .build() {
}

class InvokeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "Invoke", {})
    .n("LambdaClient", "InvokeCommand")
    .sc(Invoke)
    .build() {
}

class InvokeWithResponseStreamCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "InvokeWithResponseStream", {
    eventStream: {
        output: true,
    },
})
    .n("LambdaClient", "InvokeWithResponseStreamCommand")
    .sc(InvokeWithResponseStream)
    .build() {
}

class ListAliasesCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListAliases", {})
    .n("LambdaClient", "ListAliasesCommand")
    .sc(ListAliases)
    .build() {
}

class ListCodeSigningConfigsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListCodeSigningConfigs", {})
    .n("LambdaClient", "ListCodeSigningConfigsCommand")
    .sc(ListCodeSigningConfigs)
    .build() {
}

class ListEventSourceMappingsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListEventSourceMappings", {})
    .n("LambdaClient", "ListEventSourceMappingsCommand")
    .sc(ListEventSourceMappings)
    .build() {
}

class ListFunctionEventInvokeConfigsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListFunctionEventInvokeConfigs", {})
    .n("LambdaClient", "ListFunctionEventInvokeConfigsCommand")
    .sc(ListFunctionEventInvokeConfigs)
    .build() {
}

class ListFunctionsByCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListFunctionsByCodeSigningConfig", {})
    .n("LambdaClient", "ListFunctionsByCodeSigningConfigCommand")
    .sc(ListFunctionsByCodeSigningConfig)
    .build() {
}

class ListFunctionsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListFunctions", {})
    .n("LambdaClient", "ListFunctionsCommand")
    .sc(ListFunctions)
    .build() {
}

class ListFunctionUrlConfigsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListFunctionUrlConfigs", {})
    .n("LambdaClient", "ListFunctionUrlConfigsCommand")
    .sc(ListFunctionUrlConfigs)
    .build() {
}

class ListLayersCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListLayers", {})
    .n("LambdaClient", "ListLayersCommand")
    .sc(ListLayers)
    .build() {
}

class ListLayerVersionsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListLayerVersions", {})
    .n("LambdaClient", "ListLayerVersionsCommand")
    .sc(ListLayerVersions)
    .build() {
}

class ListProvisionedConcurrencyConfigsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListProvisionedConcurrencyConfigs", {})
    .n("LambdaClient", "ListProvisionedConcurrencyConfigsCommand")
    .sc(ListProvisionedConcurrencyConfigs)
    .build() {
}

class ListTagsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListTags", {})
    .n("LambdaClient", "ListTagsCommand")
    .sc(ListTags)
    .build() {
}

class ListVersionsByFunctionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "ListVersionsByFunction", {})
    .n("LambdaClient", "ListVersionsByFunctionCommand")
    .sc(ListVersionsByFunction)
    .build() {
}

class PublishLayerVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PublishLayerVersion", {})
    .n("LambdaClient", "PublishLayerVersionCommand")
    .sc(PublishLayerVersion)
    .build() {
}

class PublishVersionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PublishVersion", {})
    .n("LambdaClient", "PublishVersionCommand")
    .sc(PublishVersion)
    .build() {
}

class PutFunctionCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutFunctionCodeSigningConfig", {})
    .n("LambdaClient", "PutFunctionCodeSigningConfigCommand")
    .sc(PutFunctionCodeSigningConfig)
    .build() {
}

class PutFunctionConcurrencyCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutFunctionConcurrency", {})
    .n("LambdaClient", "PutFunctionConcurrencyCommand")
    .sc(PutFunctionConcurrency)
    .build() {
}

class PutFunctionEventInvokeConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutFunctionEventInvokeConfig", {})
    .n("LambdaClient", "PutFunctionEventInvokeConfigCommand")
    .sc(PutFunctionEventInvokeConfig)
    .build() {
}

class PutFunctionRecursionConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutFunctionRecursionConfig", {})
    .n("LambdaClient", "PutFunctionRecursionConfigCommand")
    .sc(PutFunctionRecursionConfig)
    .build() {
}

class PutProvisionedConcurrencyConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutProvisionedConcurrencyConfig", {})
    .n("LambdaClient", "PutProvisionedConcurrencyConfigCommand")
    .sc(PutProvisionedConcurrencyConfig)
    .build() {
}

class PutRuntimeManagementConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "PutRuntimeManagementConfig", {})
    .n("LambdaClient", "PutRuntimeManagementConfigCommand")
    .sc(PutRuntimeManagementConfig)
    .build() {
}

class RemoveLayerVersionPermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "RemoveLayerVersionPermission", {})
    .n("LambdaClient", "RemoveLayerVersionPermissionCommand")
    .sc(RemoveLayerVersionPermission)
    .build() {
}

class RemovePermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "RemovePermission", {})
    .n("LambdaClient", "RemovePermissionCommand")
    .sc(RemovePermission)
    .build() {
}

class TagResourceCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "TagResource", {})
    .n("LambdaClient", "TagResourceCommand")
    .sc(TagResource)
    .build() {
}

class UntagResourceCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UntagResource", {})
    .n("LambdaClient", "UntagResourceCommand")
    .sc(UntagResource)
    .build() {
}

class UpdateAliasCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateAlias", {})
    .n("LambdaClient", "UpdateAliasCommand")
    .sc(UpdateAlias)
    .build() {
}

class UpdateCodeSigningConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateCodeSigningConfig", {})
    .n("LambdaClient", "UpdateCodeSigningConfigCommand")
    .sc(UpdateCodeSigningConfig)
    .build() {
}

class UpdateEventSourceMappingCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateEventSourceMapping", {})
    .n("LambdaClient", "UpdateEventSourceMappingCommand")
    .sc(UpdateEventSourceMapping)
    .build() {
}

class UpdateFunctionCodeCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateFunctionCode", {})
    .n("LambdaClient", "UpdateFunctionCodeCommand")
    .sc(UpdateFunctionCode)
    .build() {
}

class UpdateFunctionConfigurationCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateFunctionConfiguration", {})
    .n("LambdaClient", "UpdateFunctionConfigurationCommand")
    .sc(UpdateFunctionConfiguration)
    .build() {
}

class UpdateFunctionEventInvokeConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateFunctionEventInvokeConfig", {})
    .n("LambdaClient", "UpdateFunctionEventInvokeConfigCommand")
    .sc(UpdateFunctionEventInvokeConfig)
    .build() {
}

class UpdateFunctionUrlConfigCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSGirApiService", "UpdateFunctionUrlConfig", {})
    .n("LambdaClient", "UpdateFunctionUrlConfigCommand")
    .sc(UpdateFunctionUrlConfig)
    .build() {
}

const commands = {
    AddLayerVersionPermissionCommand,
    AddPermissionCommand,
    CreateAliasCommand,
    CreateCodeSigningConfigCommand,
    CreateEventSourceMappingCommand,
    CreateFunctionCommand,
    CreateFunctionUrlConfigCommand,
    DeleteAliasCommand,
    DeleteCodeSigningConfigCommand,
    DeleteEventSourceMappingCommand,
    DeleteFunctionCommand,
    DeleteFunctionCodeSigningConfigCommand,
    DeleteFunctionConcurrencyCommand,
    DeleteFunctionEventInvokeConfigCommand,
    DeleteFunctionUrlConfigCommand,
    DeleteLayerVersionCommand,
    DeleteProvisionedConcurrencyConfigCommand,
    GetAccountSettingsCommand,
    GetAliasCommand,
    GetCodeSigningConfigCommand,
    GetEventSourceMappingCommand,
    GetFunctionCommand,
    GetFunctionCodeSigningConfigCommand,
    GetFunctionConcurrencyCommand,
    GetFunctionConfigurationCommand,
    GetFunctionEventInvokeConfigCommand,
    GetFunctionRecursionConfigCommand,
    GetFunctionUrlConfigCommand,
    GetLayerVersionCommand,
    GetLayerVersionByArnCommand,
    GetLayerVersionPolicyCommand,
    GetPolicyCommand,
    GetProvisionedConcurrencyConfigCommand,
    GetRuntimeManagementConfigCommand,
    InvokeCommand,
    InvokeAsyncCommand,
    InvokeWithResponseStreamCommand,
    ListAliasesCommand,
    ListCodeSigningConfigsCommand,
    ListEventSourceMappingsCommand,
    ListFunctionEventInvokeConfigsCommand,
    ListFunctionsCommand,
    ListFunctionsByCodeSigningConfigCommand,
    ListFunctionUrlConfigsCommand,
    ListLayersCommand,
    ListLayerVersionsCommand,
    ListProvisionedConcurrencyConfigsCommand,
    ListTagsCommand,
    ListVersionsByFunctionCommand,
    PublishLayerVersionCommand,
    PublishVersionCommand,
    PutFunctionCodeSigningConfigCommand,
    PutFunctionConcurrencyCommand,
    PutFunctionEventInvokeConfigCommand,
    PutFunctionRecursionConfigCommand,
    PutProvisionedConcurrencyConfigCommand,
    PutRuntimeManagementConfigCommand,
    RemoveLayerVersionPermissionCommand,
    RemovePermissionCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateAliasCommand,
    UpdateCodeSigningConfigCommand,
    UpdateEventSourceMappingCommand,
    UpdateFunctionCodeCommand,
    UpdateFunctionConfigurationCommand,
    UpdateFunctionEventInvokeConfigCommand,
    UpdateFunctionUrlConfigCommand,
};
class Lambda extends LambdaClient {
}
smithyClient.createAggregatedClient(commands, Lambda);

const paginateListAliases = core.createPaginator(LambdaClient, ListAliasesCommand, "Marker", "NextMarker", "MaxItems");

const paginateListCodeSigningConfigs = core.createPaginator(LambdaClient, ListCodeSigningConfigsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListEventSourceMappings = core.createPaginator(LambdaClient, ListEventSourceMappingsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListFunctionEventInvokeConfigs = core.createPaginator(LambdaClient, ListFunctionEventInvokeConfigsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListFunctionUrlConfigs = core.createPaginator(LambdaClient, ListFunctionUrlConfigsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListFunctionsByCodeSigningConfig = core.createPaginator(LambdaClient, ListFunctionsByCodeSigningConfigCommand, "Marker", "NextMarker", "MaxItems");

const paginateListFunctions = core.createPaginator(LambdaClient, ListFunctionsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListLayerVersions = core.createPaginator(LambdaClient, ListLayerVersionsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListLayers = core.createPaginator(LambdaClient, ListLayersCommand, "Marker", "NextMarker", "MaxItems");

const paginateListProvisionedConcurrencyConfigs = core.createPaginator(LambdaClient, ListProvisionedConcurrencyConfigsCommand, "Marker", "NextMarker", "MaxItems");

const paginateListVersionsByFunction = core.createPaginator(LambdaClient, ListVersionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");

const checkState$5 = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionConfigurationCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Active") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Failed") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Pending") {
                return { state: utilWaiter.WaiterState.RETRY, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForFunctionActive = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 300 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
};
const waitUntilFunctionActive = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 300 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
    return utilWaiter.checkExceptions(result);
};

const checkState$4 = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.Configuration.State;
            };
            if (returnComparator() === "Active") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Configuration.State;
            };
            if (returnComparator() === "Failed") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Configuration.State;
            };
            if (returnComparator() === "Pending") {
                return { state: utilWaiter.WaiterState.RETRY, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForFunctionActiveV2 = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 300 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
};
const waitUntilFunctionActiveV2 = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 300 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
    return utilWaiter.checkExceptions(result);
};

const checkState$3 = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionCommand(input));
        reason = result;
        return { state: utilWaiter.WaiterState.SUCCESS, reason };
    }
    catch (exception) {
        reason = exception;
        if (exception.name && exception.name == "ResourceNotFoundException") {
            return { state: utilWaiter.WaiterState.RETRY, reason };
        }
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForFunctionExists = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 20 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
};
const waitUntilFunctionExists = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 20 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
    return utilWaiter.checkExceptions(result);
};

const checkState$2 = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionConfigurationCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.LastUpdateStatus;
            };
            if (returnComparator() === "Successful") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.LastUpdateStatus;
            };
            if (returnComparator() === "Failed") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.LastUpdateStatus;
            };
            if (returnComparator() === "InProgress") {
                return { state: utilWaiter.WaiterState.RETRY, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForFunctionUpdated = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 300 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
};
const waitUntilFunctionUpdated = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 300 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
    return utilWaiter.checkExceptions(result);
};

const checkState$1 = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.Configuration.LastUpdateStatus;
            };
            if (returnComparator() === "Successful") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Configuration.LastUpdateStatus;
            };
            if (returnComparator() === "Failed") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.Configuration.LastUpdateStatus;
            };
            if (returnComparator() === "InProgress") {
                return { state: utilWaiter.WaiterState.RETRY, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForFunctionUpdatedV2 = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 300 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
};
const waitUntilFunctionUpdatedV2 = async (params, input) => {
    const serviceDefaults = { minDelay: 1, maxDelay: 300 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
    return utilWaiter.checkExceptions(result);
};

const checkState = async (client, input) => {
    let reason;
    try {
        const result = await client.send(new GetFunctionConfigurationCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Active") {
                return { state: utilWaiter.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Failed") {
                return { state: utilWaiter.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.State;
            };
            if (returnComparator() === "Pending") {
                return { state: utilWaiter.WaiterState.RETRY, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: utilWaiter.WaiterState.RETRY, reason };
};
const waitForPublishedVersionActive = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
};
const waitUntilPublishedVersionActive = async (params, input) => {
    const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
    return utilWaiter.checkExceptions(result);
};

Object.defineProperty(exports, "$Command", {
    enumerable: true,
    get: function () { return smithyClient.Command; }
});
Object.defineProperty(exports, "__Client", {
    enumerable: true,
    get: function () { return smithyClient.Client; }
});
exports.AddLayerVersionPermissionCommand = AddLayerVersionPermissionCommand;
exports.AddPermissionCommand = AddPermissionCommand;
exports.ApplicationLogLevel = ApplicationLogLevel;
exports.Architecture = Architecture;
exports.CodeSigningConfigNotFoundException = CodeSigningConfigNotFoundException$1;
exports.CodeSigningPolicy = CodeSigningPolicy;
exports.CodeStorageExceededException = CodeStorageExceededException$1;
exports.CodeVerificationFailedException = CodeVerificationFailedException$1;
exports.CreateAliasCommand = CreateAliasCommand;
exports.CreateCodeSigningConfigCommand = CreateCodeSigningConfigCommand;
exports.CreateEventSourceMappingCommand = CreateEventSourceMappingCommand;
exports.CreateFunctionCommand = CreateFunctionCommand;
exports.CreateFunctionUrlConfigCommand = CreateFunctionUrlConfigCommand;
exports.DeleteAliasCommand = DeleteAliasCommand;
exports.DeleteCodeSigningConfigCommand = DeleteCodeSigningConfigCommand;
exports.DeleteEventSourceMappingCommand = DeleteEventSourceMappingCommand;
exports.DeleteFunctionCodeSigningConfigCommand = DeleteFunctionCodeSigningConfigCommand;
exports.DeleteFunctionCommand = DeleteFunctionCommand;
exports.DeleteFunctionConcurrencyCommand = DeleteFunctionConcurrencyCommand;
exports.DeleteFunctionEventInvokeConfigCommand = DeleteFunctionEventInvokeConfigCommand;
exports.DeleteFunctionUrlConfigCommand = DeleteFunctionUrlConfigCommand;
exports.DeleteLayerVersionCommand = DeleteLayerVersionCommand;
exports.DeleteProvisionedConcurrencyConfigCommand = DeleteProvisionedConcurrencyConfigCommand;
exports.EC2AccessDeniedException = EC2AccessDeniedException$1;
exports.EC2ThrottledException = EC2ThrottledException$1;
exports.EC2UnexpectedException = EC2UnexpectedException$1;
exports.EFSIOException = EFSIOException$1;
exports.EFSMountConnectivityException = EFSMountConnectivityException$1;
exports.EFSMountFailureException = EFSMountFailureException$1;
exports.EFSMountTimeoutException = EFSMountTimeoutException$1;
exports.ENILimitReachedException = ENILimitReachedException$1;
exports.EndPointType = EndPointType;
exports.EventSourceMappingMetric = EventSourceMappingMetric;
exports.EventSourcePosition = EventSourcePosition;
exports.FullDocument = FullDocument;
exports.FunctionResponseType = FunctionResponseType;
exports.FunctionUrlAuthType = FunctionUrlAuthType;
exports.FunctionVersion = FunctionVersion;
exports.GetAccountSettingsCommand = GetAccountSettingsCommand;
exports.GetAliasCommand = GetAliasCommand;
exports.GetCodeSigningConfigCommand = GetCodeSigningConfigCommand;
exports.GetEventSourceMappingCommand = GetEventSourceMappingCommand;
exports.GetFunctionCodeSigningConfigCommand = GetFunctionCodeSigningConfigCommand;
exports.GetFunctionCommand = GetFunctionCommand;
exports.GetFunctionConcurrencyCommand = GetFunctionConcurrencyCommand;
exports.GetFunctionConfigurationCommand = GetFunctionConfigurationCommand;
exports.GetFunctionEventInvokeConfigCommand = GetFunctionEventInvokeConfigCommand;
exports.GetFunctionRecursionConfigCommand = GetFunctionRecursionConfigCommand;
exports.GetFunctionUrlConfigCommand = GetFunctionUrlConfigCommand;
exports.GetLayerVersionByArnCommand = GetLayerVersionByArnCommand;
exports.GetLayerVersionCommand = GetLayerVersionCommand;
exports.GetLayerVersionPolicyCommand = GetLayerVersionPolicyCommand;
exports.GetPolicyCommand = GetPolicyCommand;
exports.GetProvisionedConcurrencyConfigCommand = GetProvisionedConcurrencyConfigCommand;
exports.GetRuntimeManagementConfigCommand = GetRuntimeManagementConfigCommand;
exports.InvalidCodeSignatureException = InvalidCodeSignatureException$1;
exports.InvalidParameterValueException = InvalidParameterValueException$1;
exports.InvalidRequestContentException = InvalidRequestContentException$1;
exports.InvalidRuntimeException = InvalidRuntimeException$1;
exports.InvalidSecurityGroupIDException = InvalidSecurityGroupIDException$1;
exports.InvalidSubnetIDException = InvalidSubnetIDException$1;
exports.InvalidZipFileException = InvalidZipFileException$1;
exports.InvocationType = InvocationType;
exports.InvokeAsyncCommand = InvokeAsyncCommand;
exports.InvokeCommand = InvokeCommand;
exports.InvokeMode = InvokeMode;
exports.InvokeWithResponseStreamCommand = InvokeWithResponseStreamCommand;
exports.KMSAccessDeniedException = KMSAccessDeniedException$1;
exports.KMSDisabledException = KMSDisabledException$1;
exports.KMSInvalidStateException = KMSInvalidStateException$1;
exports.KMSNotFoundException = KMSNotFoundException$1;
exports.KafkaSchemaRegistryAuthType = KafkaSchemaRegistryAuthType;
exports.KafkaSchemaValidationAttribute = KafkaSchemaValidationAttribute;
exports.Lambda = Lambda;
exports.LambdaClient = LambdaClient;
exports.LambdaServiceException = LambdaServiceException$1;
exports.LastUpdateStatus = LastUpdateStatus;
exports.LastUpdateStatusReasonCode = LastUpdateStatusReasonCode;
exports.ListAliasesCommand = ListAliasesCommand;
exports.ListCodeSigningConfigsCommand = ListCodeSigningConfigsCommand;
exports.ListEventSourceMappingsCommand = ListEventSourceMappingsCommand;
exports.ListFunctionEventInvokeConfigsCommand = ListFunctionEventInvokeConfigsCommand;
exports.ListFunctionUrlConfigsCommand = ListFunctionUrlConfigsCommand;
exports.ListFunctionsByCodeSigningConfigCommand = ListFunctionsByCodeSigningConfigCommand;
exports.ListFunctionsCommand = ListFunctionsCommand;
exports.ListLayerVersionsCommand = ListLayerVersionsCommand;
exports.ListLayersCommand = ListLayersCommand;
exports.ListProvisionedConcurrencyConfigsCommand = ListProvisionedConcurrencyConfigsCommand;
exports.ListTagsCommand = ListTagsCommand;
exports.ListVersionsByFunctionCommand = ListVersionsByFunctionCommand;
exports.LogFormat = LogFormat;
exports.LogType = LogType;
exports.PackageType = PackageType;
exports.PolicyLengthExceededException = PolicyLengthExceededException$1;
exports.PreconditionFailedException = PreconditionFailedException$1;
exports.ProvisionedConcurrencyConfigNotFoundException = ProvisionedConcurrencyConfigNotFoundException$1;
exports.ProvisionedConcurrencyStatusEnum = ProvisionedConcurrencyStatusEnum;
exports.PublishLayerVersionCommand = PublishLayerVersionCommand;
exports.PublishVersionCommand = PublishVersionCommand;
exports.PutFunctionCodeSigningConfigCommand = PutFunctionCodeSigningConfigCommand;
exports.PutFunctionConcurrencyCommand = PutFunctionConcurrencyCommand;
exports.PutFunctionEventInvokeConfigCommand = PutFunctionEventInvokeConfigCommand;
exports.PutFunctionRecursionConfigCommand = PutFunctionRecursionConfigCommand;
exports.PutProvisionedConcurrencyConfigCommand = PutProvisionedConcurrencyConfigCommand;
exports.PutRuntimeManagementConfigCommand = PutRuntimeManagementConfigCommand;
exports.RecursiveInvocationException = RecursiveInvocationException$1;
exports.RecursiveLoop = RecursiveLoop;
exports.RemoveLayerVersionPermissionCommand = RemoveLayerVersionPermissionCommand;
exports.RemovePermissionCommand = RemovePermissionCommand;
exports.RequestTooLargeException = RequestTooLargeException$1;
exports.ResourceConflictException = ResourceConflictException$1;
exports.ResourceInUseException = ResourceInUseException$1;
exports.ResourceNotFoundException = ResourceNotFoundException$1;
exports.ResourceNotReadyException = ResourceNotReadyException$1;
exports.ResponseStreamingInvocationType = ResponseStreamingInvocationType;
exports.Runtime = Runtime;
exports.SchemaRegistryEventRecordFormat = SchemaRegistryEventRecordFormat;
exports.SerializedRequestEntityTooLargeException = SerializedRequestEntityTooLargeException$1;
exports.ServiceException = ServiceException$1;
exports.SnapStartApplyOn = SnapStartApplyOn;
exports.SnapStartException = SnapStartException$1;
exports.SnapStartNotReadyException = SnapStartNotReadyException$1;
exports.SnapStartOptimizationStatus = SnapStartOptimizationStatus;
exports.SnapStartTimeoutException = SnapStartTimeoutException$1;
exports.SourceAccessType = SourceAccessType;
exports.State = State;
exports.StateReasonCode = StateReasonCode;
exports.SubnetIPAddressLimitReachedException = SubnetIPAddressLimitReachedException$1;
exports.SystemLogLevel = SystemLogLevel;
exports.TagResourceCommand = TagResourceCommand;
exports.ThrottleReason = ThrottleReason;
exports.TooManyRequestsException = TooManyRequestsException$1;
exports.TracingMode = TracingMode;
exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException$1;
exports.UntagResourceCommand = UntagResourceCommand;
exports.UpdateAliasCommand = UpdateAliasCommand;
exports.UpdateCodeSigningConfigCommand = UpdateCodeSigningConfigCommand;
exports.UpdateEventSourceMappingCommand = UpdateEventSourceMappingCommand;
exports.UpdateFunctionCodeCommand = UpdateFunctionCodeCommand;
exports.UpdateFunctionConfigurationCommand = UpdateFunctionConfigurationCommand;
exports.UpdateFunctionEventInvokeConfigCommand = UpdateFunctionEventInvokeConfigCommand;
exports.UpdateFunctionUrlConfigCommand = UpdateFunctionUrlConfigCommand;
exports.UpdateRuntimeOn = UpdateRuntimeOn;
exports.paginateListAliases = paginateListAliases;
exports.paginateListCodeSigningConfigs = paginateListCodeSigningConfigs;
exports.paginateListEventSourceMappings = paginateListEventSourceMappings;
exports.paginateListFunctionEventInvokeConfigs = paginateListFunctionEventInvokeConfigs;
exports.paginateListFunctionUrlConfigs = paginateListFunctionUrlConfigs;
exports.paginateListFunctions = paginateListFunctions;
exports.paginateListFunctionsByCodeSigningConfig = paginateListFunctionsByCodeSigningConfig;
exports.paginateListLayerVersions = paginateListLayerVersions;
exports.paginateListLayers = paginateListLayers;
exports.paginateListProvisionedConcurrencyConfigs = paginateListProvisionedConcurrencyConfigs;
exports.paginateListVersionsByFunction = paginateListVersionsByFunction;
exports.waitForFunctionActive = waitForFunctionActive;
exports.waitForFunctionActiveV2 = waitForFunctionActiveV2;
exports.waitForFunctionExists = waitForFunctionExists;
exports.waitForFunctionUpdated = waitForFunctionUpdated;
exports.waitForFunctionUpdatedV2 = waitForFunctionUpdatedV2;
exports.waitForPublishedVersionActive = waitForPublishedVersionActive;
exports.waitUntilFunctionActive = waitUntilFunctionActive;
exports.waitUntilFunctionActiveV2 = waitUntilFunctionActiveV2;
exports.waitUntilFunctionExists = waitUntilFunctionExists;
exports.waitUntilFunctionUpdated = waitUntilFunctionUpdated;
exports.waitUntilFunctionUpdatedV2 = waitUntilFunctionUpdatedV2;
exports.waitUntilPublishedVersionActive = waitUntilPublishedVersionActive;