@aws-sdk/client-imagebuilder 3.35.0 → 3.38.0

package/src/commands/CreateContainerRecipeCommand.ts

@@ -1,95 +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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import { CreateContainerRecipeRequest, CreateContainerRecipeResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateContainerRecipeCommand,
-  serializeAws_restJson1CreateContainerRecipeCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateContainerRecipeCommandInput extends CreateContainerRecipeRequest {}
-export interface CreateContainerRecipeCommandOutput extends CreateContainerRecipeResponse, __MetadataBearer {}
-
-/**
- * <p>Creates a new container recipe. Container recipes define how images are configured, tested, and assessed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateContainerRecipeCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateContainerRecipeCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateContainerRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateContainerRecipeCommandInput} for command's `input` shape.
- * @see {@link CreateContainerRecipeCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateContainerRecipeCommand extends $Command<
-  CreateContainerRecipeCommandInput,
-  CreateContainerRecipeCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateContainerRecipeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateContainerRecipeCommandInput, CreateContainerRecipeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateContainerRecipeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateContainerRecipeRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateContainerRecipeResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateContainerRecipeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateContainerRecipeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateContainerRecipeCommandOutput> {
-    return deserializeAws_restJson1CreateContainerRecipeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateDistributionConfigurationCommand.ts

@@ -1,104 +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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import { CreateDistributionConfigurationRequest, CreateDistributionConfigurationResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateDistributionConfigurationCommand,
-  serializeAws_restJson1CreateDistributionConfigurationCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateDistributionConfigurationCommandInput extends CreateDistributionConfigurationRequest {}
-export interface CreateDistributionConfigurationCommandOutput
-  extends CreateDistributionConfigurationResponse,
-    __MetadataBearer {}
-
-/**
- * <p>Creates a new distribution configuration. Distribution configurations define and configure
- * 			the outputs of your pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateDistributionConfigurationCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateDistributionConfigurationCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateDistributionConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDistributionConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateDistributionConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateDistributionConfigurationCommand extends $Command<
-  CreateDistributionConfigurationCommandInput,
-  CreateDistributionConfigurationCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDistributionConfigurationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDistributionConfigurationCommandInput, CreateDistributionConfigurationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateDistributionConfigurationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDistributionConfigurationRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDistributionConfigurationResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: CreateDistributionConfigurationCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateDistributionConfigurationCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateDistributionConfigurationCommandOutput> {
-    return deserializeAws_restJson1CreateDistributionConfigurationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateImageCommand.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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import { CreateImageRequest, CreateImageResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateImageCommand,
-  serializeAws_restJson1CreateImageCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateImageCommandInput extends CreateImageRequest {}
-export interface CreateImageCommandOutput extends CreateImageResponse, __MetadataBearer {}
-
-/**
- * <p> Creates a new image. This request will create a new image along with all of the
- * 			configured output resources defined in the distribution configuration. You must specify
- * 			exactly one recipe for your image, using either a ContainerRecipeArn or an ImageRecipeArn.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateImageCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateImageCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageCommandInput} for command's `input` shape.
- * @see {@link CreateImageCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateImageCommand extends $Command<
-  CreateImageCommandInput,
-  CreateImageCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateImageCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateImageCommandInput, CreateImageCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateImageCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateImageRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateImageResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateImageCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateImageCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateImageCommandOutput> {
-    return deserializeAws_restJson1CreateImageCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateImagePipelineCommand.ts

@@ -1,96 +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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import { CreateImagePipelineRequest, CreateImagePipelineResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateImagePipelineCommand,
-  serializeAws_restJson1CreateImagePipelineCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateImagePipelineCommandInput extends CreateImagePipelineRequest {}
-export interface CreateImagePipelineCommandOutput extends CreateImagePipelineResponse, __MetadataBearer {}
-
-/**
- * <p> Creates a new image pipeline. Image pipelines enable you to automate the creation and
- * 			distribution of images.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateImagePipelineCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateImagePipelineCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateImagePipelineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImagePipelineCommandInput} for command's `input` shape.
- * @see {@link CreateImagePipelineCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateImagePipelineCommand extends $Command<
-  CreateImagePipelineCommandInput,
-  CreateImagePipelineCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateImagePipelineCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateImagePipelineCommandInput, CreateImagePipelineCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateImagePipelineCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateImagePipelineRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateImagePipelineResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateImagePipelineCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateImagePipelineCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateImagePipelineCommandOutput> {
-    return deserializeAws_restJson1CreateImagePipelineCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateImageRecipeCommand.ts

@@ -1,96 +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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import { CreateImageRecipeRequest, CreateImageRecipeResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateImageRecipeCommand,
-  serializeAws_restJson1CreateImageRecipeCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateImageRecipeCommandInput extends CreateImageRecipeRequest {}
-export interface CreateImageRecipeCommandOutput extends CreateImageRecipeResponse, __MetadataBearer {}
-
-/**
- * <p> Creates a new image recipe. Image recipes define how images are configured, tested, and
- * 			assessed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateImageRecipeCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateImageRecipeCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateImageRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageRecipeCommandInput} for command's `input` shape.
- * @see {@link CreateImageRecipeCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateImageRecipeCommand extends $Command<
-  CreateImageRecipeCommandInput,
-  CreateImageRecipeCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateImageRecipeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateImageRecipeCommandInput, CreateImageRecipeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateImageRecipeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateImageRecipeRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateImageRecipeResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateImageRecipeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateImageRecipeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateImageRecipeCommandOutput> {
-    return deserializeAws_restJson1CreateImageRecipeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateInfrastructureConfigurationCommand.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 { ImagebuilderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ImagebuilderClient";
-import {
-  CreateInfrastructureConfigurationRequest,
-  CreateInfrastructureConfigurationResponse,
-} from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateInfrastructureConfigurationCommand,
-  serializeAws_restJson1CreateInfrastructureConfigurationCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateInfrastructureConfigurationCommandInput extends CreateInfrastructureConfigurationRequest {}
-export interface CreateInfrastructureConfigurationCommandOutput
-  extends CreateInfrastructureConfigurationResponse,
-    __MetadataBearer {}
-
-/**
- * <p> Creates a new infrastructure configuration. An infrastructure configuration defines the
- * 			environment in which your image will be built and tested.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateInfrastructureConfigurationCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateInfrastructureConfigurationCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateInfrastructureConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInfrastructureConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateInfrastructureConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateInfrastructureConfigurationCommand extends $Command<
-  CreateInfrastructureConfigurationCommandInput,
-  CreateInfrastructureConfigurationCommandOutput,
-  ImagebuilderClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateInfrastructureConfigurationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ImagebuilderClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateInfrastructureConfigurationCommandInput, CreateInfrastructureConfigurationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ImagebuilderClient";
-    const commandName = "CreateInfrastructureConfigurationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateInfrastructureConfigurationRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateInfrastructureConfigurationResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: CreateInfrastructureConfigurationCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateInfrastructureConfigurationCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateInfrastructureConfigurationCommandOutput> {
-    return deserializeAws_restJson1CreateInfrastructureConfigurationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}