@aws-sdk/client-lambda 3.35.0 → 3.36.0

package/src/commands/AddPermissionCommand.ts

@@ -1,107 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { AddPermissionRequest, AddPermissionResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1AddPermissionCommand,
-  serializeAws_restJson1AddPermissionCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface AddPermissionCommandInput extends AddPermissionRequest {}
-export interface AddPermissionCommandOutput extends AddPermissionResponse, __MetadataBearer {}
-
-/**
- * <p>Grants an Amazon Web Services service or another account permission to use a function. You can apply the policy at the
- *       function level, or specify a qualifier to restrict access to a single version or alias. If you use a qualifier,
- *       the invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the function.
- *       Note: Lambda does not support adding policies to version $LATEST.</p>
- *
- *          <p>To grant permission to another account, specify the account ID as the <code>Principal</code>. For Amazon Web Services
- *       services, the principal is a domain-style identifier defined by the service, like <code>s3.amazonaws.com</code> or
- *         <code>sns.amazonaws.com</code>. For Amazon Web Services services, you can also specify the ARN of the associated resource as the
- *         <code>SourceArn</code>. If you grant permission to a service principal without specifying the source, other
- *       accounts could potentially configure resources in their account to invoke your Lambda function.</p>
- *
- *          <p>This action adds a statement to a resource-based permissions policy for the function. For more information
- *       about function policies, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html">Lambda Function Policies</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, AddPermissionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, AddPermissionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new AddPermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddPermissionCommandInput} for command's `input` shape.
- * @see {@link AddPermissionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AddPermissionCommand extends $Command<
-  AddPermissionCommandInput,
-  AddPermissionCommandOutput,
-  LambdaClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AddPermissionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LambdaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AddPermissionCommandInput, AddPermissionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LambdaClient";
-    const commandName = "AddPermissionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AddPermissionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: AddPermissionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: AddPermissionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1AddPermissionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<AddPermissionCommandOutput> {
-    return deserializeAws_restJson1AddPermissionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateAliasCommand.ts

@@ -1,100 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { AliasConfiguration, CreateAliasRequest } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateAliasCommand,
-  serializeAws_restJson1CreateAliasCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateAliasCommandInput extends CreateAliasRequest {}
-export interface CreateAliasCommandOutput extends AliasConfiguration, __MetadataBearer {}
-
-/**
- * <p>Creates an <a href="https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html">alias</a> for a
- *       Lambda function version. Use aliases to provide clients with a function identifier that you can update to invoke a
- *       different version.</p>
- *          <p>You can also map an alias to split invocation requests between two versions. Use the
- *         <code>RoutingConfig</code> parameter to specify a second version and the percentage of invocation requests that
- *       it receives.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, CreateAliasCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, CreateAliasCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new CreateAliasCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAliasCommandInput} for command's `input` shape.
- * @see {@link CreateAliasCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateAliasCommand extends $Command<
-  CreateAliasCommandInput,
-  CreateAliasCommandOutput,
-  LambdaClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateAliasCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LambdaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateAliasCommandInput, CreateAliasCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LambdaClient";
-    const commandName = "CreateAliasCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateAliasRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: AliasConfiguration.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateAliasCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateAliasCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateAliasCommandOutput> {
-    return deserializeAws_restJson1CreateAliasCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateCodeSigningConfigCommand.ts

@@ -1,97 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { CreateCodeSigningConfigRequest, CreateCodeSigningConfigResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateCodeSigningConfigCommand,
-  serializeAws_restJson1CreateCodeSigningConfigCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateCodeSigningConfigCommandInput extends CreateCodeSigningConfigRequest {}
-export interface CreateCodeSigningConfigCommandOutput extends CreateCodeSigningConfigResponse, __MetadataBearer {}
-
-/**
- * <p>Creates a code signing configuration. A <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-trustedcode.html">code signing configuration</a> defines a list of
- *       allowed signing profiles and defines the code-signing validation policy (action to be taken if deployment
- *       validation checks fail). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, CreateCodeSigningConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, CreateCodeSigningConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new CreateCodeSigningConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateCodeSigningConfigCommandInput} for command's `input` shape.
- * @see {@link CreateCodeSigningConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateCodeSigningConfigCommand extends $Command<
-  CreateCodeSigningConfigCommandInput,
-  CreateCodeSigningConfigCommandOutput,
-  LambdaClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateCodeSigningConfigCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LambdaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateCodeSigningConfigCommandInput, CreateCodeSigningConfigCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LambdaClient";
-    const commandName = "CreateCodeSigningConfigCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateCodeSigningConfigRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateCodeSigningConfigResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateCodeSigningConfigCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateCodeSigningConfigCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateCodeSigningConfigCommandOutput> {
-    return deserializeAws_restJson1CreateCodeSigningConfigCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateEventSourceMappingCommand.ts

@@ -1,159 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { CreateEventSourceMappingRequest, EventSourceMappingConfiguration } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateEventSourceMappingCommand,
-  serializeAws_restJson1CreateEventSourceMappingCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateEventSourceMappingCommandInput extends CreateEventSourceMappingRequest {}
-export interface CreateEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {}
-
-/**
- * <p>Creates a mapping between an event source and an Lambda function. Lambda reads items from the
- *       event source and triggers the function.</p>
- *          <p>For details about each event source type, see the following topics. </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-dynamodb-eventsourcemapping">
- *             Configuring a Dynamo DB stream as an event source</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html#services-kinesis-eventsourcemapping">
- *             Configuring a Kinesis stream as an event source</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-eventsource"> Configuring an
- *               Amazon SQS queue as an event source</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping">
- *             Configuring an MQ broker as an event source</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html"> Configuring MSK as an event
- *             source</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/lambda/latest/dg/kafka-smaa.html"> Configuring Self-Managed Apache Kafka
- *             as an event source</a>
- *                </p>
- *             </li>
- *          </ul>
- *
- *          <p>The following error handling options are only available for stream sources (DynamoDB and Kinesis):</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>BisectBatchOnFunctionError</code> - If the function returns an error, split the batch in two and retry.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>DestinationConfig</code> - Send discarded records to an Amazon SQS queue or Amazon SNS topic.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRecordAgeInSeconds</code> - Discard records older than the specified age. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRetryAttempts</code> - Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ParallelizationFactor</code> - Process multiple batches from each shard concurrently.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, CreateEventSourceMappingCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, CreateEventSourceMappingCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new CreateEventSourceMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEventSourceMappingCommandInput} for command's `input` shape.
- * @see {@link CreateEventSourceMappingCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateEventSourceMappingCommand extends $Command<
-  CreateEventSourceMappingCommandInput,
-  CreateEventSourceMappingCommandOutput,
-  LambdaClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateEventSourceMappingCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LambdaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEventSourceMappingCommandInput, CreateEventSourceMappingCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LambdaClient";
-    const commandName = "CreateEventSourceMappingCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateEventSourceMappingRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: EventSourceMappingConfiguration.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateEventSourceMappingCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateEventSourceMappingCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateEventSourceMappingCommandOutput> {
-    return deserializeAws_restJson1CreateEventSourceMappingCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateFunctionCommand.ts

@@ -1,141 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { CreateFunctionRequest, FunctionConfiguration } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateFunctionCommand,
-  serializeAws_restJson1CreateFunctionCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateFunctionCommandInput extends CreateFunctionRequest {}
-export interface CreateFunctionCommandOutput extends FunctionConfiguration, __MetadataBearer {}
-
-/**
- * <p>Creates a Lambda function. To create a function, you need a <a href="https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html">deployment package</a> and an <a href="https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role">execution role</a>. The
- *       deployment package is a .zip file  archive or container image that contains your function code. The execution role grants the function permission to use Amazon Web Services
- *       services, such as Amazon CloudWatch Logs for log streaming and X-Ray for request tracing.</p>
- *
- *          <p>You set the package type to <code>Image</code> if the deployment package is a
- *       <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-images.html">container image</a>. For a container image,
- *       the code property must include the URI of a container image in the Amazon ECR registry.
- *       You do not need to specify the handler and runtime properties. </p>
- *
- *          <p>You set the package type to <code>Zip</code> if the deployment package is a <a href="https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html#gettingstarted-package-zip">.zip file
- *         archive</a>. For a .zip file archive, the code property specifies the location of the
- *       .zip file. You must also specify the handler and runtime properties. The code in the
- *       deployment package must be compatible with the target instruction set architecture of the
- *       function (<code>x86-64</code> or <code>arm64</code>). If you do not specify the architecture, the default value is
- *       <code>x86-64</code>.</p>
- *
- *          <p>When you create a function, Lambda provisions an instance of the function and its supporting resources. If
- *       your function connects to a VPC, this process can take a minute or so. During this time, you can't invoke or
- *       modify the function. The <code>State</code>, <code>StateReason</code>, and <code>StateReasonCode</code> fields in
- *       the response from <a>GetFunctionConfiguration</a> indicate when the function is ready to invoke. For
- *       more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/functions-states.html">Function
- *         States</a>.</p>
- *
- *          <p>A function has an unpublished version, and can have published versions and aliases. The unpublished version
- *       changes when you update your function's code and configuration. A published version is a snapshot of your function
- *       code and configuration that can't be changed. An alias is a named resource that maps to a version, and can be
- *       changed to map to a different version. Use the <code>Publish</code> parameter to create version <code>1</code> of
- *       your function from its initial configuration.</p>
- *
- *          <p>The other parameters let you configure version-specific and function-level settings. You can modify
- *       version-specific settings later with <a>UpdateFunctionConfiguration</a>. Function-level settings apply
- *       to both the unpublished and published versions of the function, and include tags (<a>TagResource</a>)
- *       and per-function concurrency limits (<a>PutFunctionConcurrency</a>).</p>
- *
- *          <p>You can use code signing if your deployment package is a .zip file archive. To enable code signing for this function,
- *       specify the ARN of a code-signing configuration. When a user
- *       attempts to deploy a code package with <a>UpdateFunctionCode</a>, Lambda checks that the code
- *       package has a valid signature from a trusted publisher. The code-signing configuration
- *       includes set set of signing profiles, which define the trusted publishers for this function.</p>
- *
- *          <p>If another account or an Amazon Web Services service invokes your function, use <a>AddPermission</a> to grant
- *       permission by creating a resource-based IAM policy. You can grant permissions at the function level, on a version,
- *       or on an alias.</p>
- *
- *          <p>To invoke your function directly, use <a>Invoke</a>. To invoke your function in response to events
- *       in other Amazon Web Services services, create an event source mapping (<a>CreateEventSourceMapping</a>), or configure a
- *       function trigger in the other service. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html">Invoking Functions</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, CreateFunctionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, CreateFunctionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new CreateFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFunctionCommandInput} for command's `input` shape.
- * @see {@link CreateFunctionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateFunctionCommand extends $Command<
-  CreateFunctionCommandInput,
-  CreateFunctionCommandOutput,
-  LambdaClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateFunctionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LambdaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateFunctionCommandInput, CreateFunctionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LambdaClient";
-    const commandName = "CreateFunctionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateFunctionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: FunctionConfiguration.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateFunctionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateFunctionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateFunctionCommandOutput> {
-    return deserializeAws_restJson1CreateFunctionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}