@aws-sdk/client-proton 3.34.0 → 3.37.0

package/commands/CreateEnvironmentTemplateCommand.ts

@@ -1,112 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateEnvironmentTemplateInput, CreateEnvironmentTemplateOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateEnvironmentTemplateCommand,
-  serializeAws_json1_0CreateEnvironmentTemplateCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateEnvironmentTemplateCommandInput extends CreateEnvironmentTemplateInput {}
-export interface CreateEnvironmentTemplateCommandOutput extends CreateEnvironmentTemplateOutput, __MetadataBearer {}
-
-/**
- * <p>Create an environment template for AWS Proton. For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-templates.html">Environment Templates</a> in the <i>AWS Proton Administrator
- *                 Guide</i>.</p>
- *         <p>You can create an environment template in one of the two following ways:</p>
- *         <ul>
- *             <li>
- *                 <p>Register and publish a <i>standard</i> environment template that instructs AWS Proton to deploy and manage
- *                     environment infrastructure.</p>
- *             </li>
- *             <li>
- *                 <p>Register and publish a <i>customer managed</i> environment template that connects AWS Proton to your existing
- *                     provisioned infrastructure that you manage. AWS Proton <i>doesn't</i> manage your existing provisioned
- *                     infrastructure. To create an environment template for customer provisioned and managed infrastructure, include the
- *                         <code>provisioning</code> parameter and set the value to <code>CUSTOMER_MANAGED</code>. For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/template-create.html">Register and publish an environment template</a>
- *                     in the <i>AWS Proton Administrator Guide</i>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, CreateEnvironmentTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, CreateEnvironmentTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new CreateEnvironmentTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEnvironmentTemplateCommandInput} for command's `input` shape.
- * @see {@link CreateEnvironmentTemplateCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateEnvironmentTemplateCommand extends $Command<
-  CreateEnvironmentTemplateCommandInput,
-  CreateEnvironmentTemplateCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateEnvironmentTemplateCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEnvironmentTemplateCommandInput, CreateEnvironmentTemplateCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "CreateEnvironmentTemplateCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateEnvironmentTemplateInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateEnvironmentTemplateOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateEnvironmentTemplateCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateEnvironmentTemplateCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateEnvironmentTemplateCommandOutput> {
-    return deserializeAws_json1_0CreateEnvironmentTemplateCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateEnvironmentTemplateVersionCommand.ts

@@ -1,104 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateEnvironmentTemplateVersionInput, CreateEnvironmentTemplateVersionOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateEnvironmentTemplateVersionCommand,
-  serializeAws_json1_0CreateEnvironmentTemplateVersionCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateEnvironmentTemplateVersionCommandInput extends CreateEnvironmentTemplateVersionInput {}
-export interface CreateEnvironmentTemplateVersionCommandOutput
-  extends CreateEnvironmentTemplateVersionOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Create a new major or minor version of an environment template. A major version of an environment template is a version that
- *                 <i>isn't</i> backwards compatible. A minor version of an environment template is a version that's backwards compatible
- *             within its major version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, CreateEnvironmentTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, CreateEnvironmentTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new CreateEnvironmentTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEnvironmentTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link CreateEnvironmentTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateEnvironmentTemplateVersionCommand extends $Command<
-  CreateEnvironmentTemplateVersionCommandInput,
-  CreateEnvironmentTemplateVersionCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateEnvironmentTemplateVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEnvironmentTemplateVersionCommandInput, CreateEnvironmentTemplateVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "CreateEnvironmentTemplateVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateEnvironmentTemplateVersionInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateEnvironmentTemplateVersionOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: CreateEnvironmentTemplateVersionCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateEnvironmentTemplateVersionCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateEnvironmentTemplateVersionCommandOutput> {
-    return deserializeAws_json1_0CreateEnvironmentTemplateVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateServiceCommand.ts

@@ -1,96 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceInput, CreateServiceOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateServiceCommand,
-  serializeAws_json1_0CreateServiceCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateServiceCommandInput extends CreateServiceInput {}
-export interface CreateServiceCommandOutput extends CreateServiceOutput, __MetadataBearer {}
-
-/**
- * <p>Create an AWS Proton service. An AWS Proton service is an instantiation of a service template and often includes several service instances
- *             and pipeline. For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-services.html">Services</a> in
- *             the <i>AWS Proton Administrator Guide</i> and <a href="https://docs.aws.amazon.com/proton/latest/userguide/ug-service.html">Services</a> in the <i>AWS Proton User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, CreateServiceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, CreateServiceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new CreateServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateServiceCommandInput} for command's `input` shape.
- * @see {@link CreateServiceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateServiceCommand extends $Command<
-  CreateServiceCommandInput,
-  CreateServiceCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateServiceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateServiceCommandInput, CreateServiceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "CreateServiceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateServiceInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateServiceOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateServiceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateServiceCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateServiceCommandOutput> {
-    return deserializeAws_json1_0CreateServiceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateServiceTemplateCommand.ts

@@ -1,98 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceTemplateInput, CreateServiceTemplateOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateServiceTemplateCommand,
-  serializeAws_json1_0CreateServiceTemplateCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateServiceTemplateCommandInput extends CreateServiceTemplateInput {}
-export interface CreateServiceTemplateCommandOutput extends CreateServiceTemplateOutput, __MetadataBearer {}
-
-/**
- * <p>Create a service template. The administrator creates a service template to define standardized infrastructure and an optional CICD
- *             service pipeline. Developers, in turn, select the service template from AWS Proton. If the selected service template includes a service
- *             pipeline definition, they provide a link to their source code repository. AWS Proton then deploys and manages the infrastructure defined by
- *             the selected service template. For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/managing-svc-templates.html">Service Templates</a> in the <i>AWS Proton Administrator
- *                 Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, CreateServiceTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, CreateServiceTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new CreateServiceTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateServiceTemplateCommandInput} for command's `input` shape.
- * @see {@link CreateServiceTemplateCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateServiceTemplateCommand extends $Command<
-  CreateServiceTemplateCommandInput,
-  CreateServiceTemplateCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateServiceTemplateCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateServiceTemplateCommandInput, CreateServiceTemplateCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "CreateServiceTemplateCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateServiceTemplateInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateServiceTemplateOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateServiceTemplateCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateServiceTemplateCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateServiceTemplateCommandOutput> {
-    return deserializeAws_json1_0CreateServiceTemplateCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateServiceTemplateVersionCommand.ts

@@ -1,101 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceTemplateVersionInput, CreateServiceTemplateVersionOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateServiceTemplateVersionCommand,
-  serializeAws_json1_0CreateServiceTemplateVersionCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateServiceTemplateVersionCommandInput extends CreateServiceTemplateVersionInput {}
-export interface CreateServiceTemplateVersionCommandOutput
-  extends CreateServiceTemplateVersionOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Create a new major or minor version of a service template. A major version of a service template is a version that
- *                 <i>isn't</i> backwards compatible. A minor version of a service template is a version that's backwards compatible within
- *             its major version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, CreateServiceTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, CreateServiceTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new CreateServiceTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateServiceTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link CreateServiceTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateServiceTemplateVersionCommand extends $Command<
-  CreateServiceTemplateVersionCommandInput,
-  CreateServiceTemplateVersionCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateServiceTemplateVersionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateServiceTemplateVersionCommandInput, CreateServiceTemplateVersionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "CreateServiceTemplateVersionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateServiceTemplateVersionInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateServiceTemplateVersionOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateServiceTemplateVersionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateServiceTemplateVersionCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateServiceTemplateVersionCommandOutput> {
-    return deserializeAws_json1_0CreateServiceTemplateVersionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteEnvironmentAccountConnectionCommand.ts

@@ -1,107 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteEnvironmentAccountConnectionInput, DeleteEnvironmentAccountConnectionOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DeleteEnvironmentAccountConnectionCommand,
-  serializeAws_json1_0DeleteEnvironmentAccountConnectionCommand,
-} from "../protocols/Aws_json1_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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteEnvironmentAccountConnectionCommandInput extends DeleteEnvironmentAccountConnectionInput {}
-export interface DeleteEnvironmentAccountConnectionCommandOutput
-  extends DeleteEnvironmentAccountConnectionOutput,
-    __MetadataBearer {}
-
-/**
- * <p>In an environment account, delete an environment account connection.</p>
- *         <p>After you delete an environment account connection that’s in use by an AWS Proton environment, AWS Proton <i>can’t</i>
- *             manage the environment infrastructure resources until a new environment account connection is accepted for the environment account and
- *             associated environment. You're responsible for cleaning up provisioned resources that remain without an environment connection.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-account-connections.html">Environment account
- *                 connections</a> in the <i>AWS Proton Administrator guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteEnvironmentAccountConnectionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteEnvironmentAccountConnectionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteEnvironmentAccountConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentAccountConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentAccountConnectionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteEnvironmentAccountConnectionCommand extends $Command<
-  DeleteEnvironmentAccountConnectionCommandInput,
-  DeleteEnvironmentAccountConnectionCommandOutput,
-  ProtonClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteEnvironmentAccountConnectionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: ProtonClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteEnvironmentAccountConnectionCommandInput, DeleteEnvironmentAccountConnectionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "ProtonClient";
-    const commandName = "DeleteEnvironmentAccountConnectionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteEnvironmentAccountConnectionInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteEnvironmentAccountConnectionOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: DeleteEnvironmentAccountConnectionCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_0DeleteEnvironmentAccountConnectionCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<DeleteEnvironmentAccountConnectionCommandOutput> {
-    return deserializeAws_json1_0DeleteEnvironmentAccountConnectionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}