@aws-sdk/client-proton 3.34.0 → 3.37.0

package/dist/types/commands/CreateEnvironmentTemplateVersionCommand.d.ts

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateEnvironmentTemplateVersionInput, CreateEnvironmentTemplateVersionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateEnvironmentTemplateVersionCommand extends $Command<CreateEnvironmentTemplateVersionCommandInput, CreateEnvironmentTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: CreateEnvironmentTemplateVersionCommandInput;
-    constructor(input: CreateEnvironmentTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEnvironmentTemplateVersionCommandInput, CreateEnvironmentTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateServiceCommand.d.ts

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceInput, CreateServiceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateServiceCommand extends $Command<CreateServiceCommandInput, CreateServiceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: CreateServiceCommandInput;
-    constructor(input: CreateServiceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceCommandInput, CreateServiceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateServiceTemplateCommand.d.ts

@@ -1,39 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceTemplateInput, CreateServiceTemplateOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateServiceTemplateCommand extends $Command<CreateServiceTemplateCommandInput, CreateServiceTemplateCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: CreateServiceTemplateCommandInput;
-    constructor(input: CreateServiceTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceTemplateCommandInput, CreateServiceTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateServiceTemplateVersionCommand.d.ts

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { CreateServiceTemplateVersionInput, CreateServiceTemplateVersionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateServiceTemplateVersionCommand extends $Command<CreateServiceTemplateVersionCommandInput, CreateServiceTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: CreateServiceTemplateVersionCommandInput;
-    constructor(input: CreateServiceTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceTemplateVersionCommandInput, CreateServiceTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteEnvironmentAccountConnectionCommand.d.ts

@@ -1,40 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteEnvironmentAccountConnectionInput, DeleteEnvironmentAccountConnectionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class DeleteEnvironmentAccountConnectionCommand extends $Command<DeleteEnvironmentAccountConnectionCommandInput, DeleteEnvironmentAccountConnectionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteEnvironmentAccountConnectionCommandInput;
-    constructor(input: DeleteEnvironmentAccountConnectionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentAccountConnectionCommandInput, DeleteEnvironmentAccountConnectionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteEnvironmentCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteEnvironmentInput, DeleteEnvironmentOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEnvironmentCommandInput extends DeleteEnvironmentInput {
-}
-export interface DeleteEnvironmentCommandOutput extends DeleteEnvironmentOutput, __MetadataBearer {
-}
-/**
- * <p>Delete an environment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteEnvironmentCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteEnvironmentCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEnvironmentCommand extends $Command<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteEnvironmentCommandInput;
-    constructor(input: DeleteEnvironmentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteEnvironmentTemplateCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteEnvironmentTemplateInput, DeleteEnvironmentTemplateOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEnvironmentTemplateCommandInput extends DeleteEnvironmentTemplateInput {
-}
-export interface DeleteEnvironmentTemplateCommandOutput extends DeleteEnvironmentTemplateOutput, __MetadataBearer {
-}
-/**
- * <p>If no other major or minor versions of an environment template exist, delete the environment template.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteEnvironmentTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteEnvironmentTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteEnvironmentTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentTemplateCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEnvironmentTemplateCommand extends $Command<DeleteEnvironmentTemplateCommandInput, DeleteEnvironmentTemplateCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteEnvironmentTemplateCommandInput;
-    constructor(input: DeleteEnvironmentTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentTemplateCommandInput, DeleteEnvironmentTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteEnvironmentTemplateVersionCommand.d.ts

@@ -1,41 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteEnvironmentTemplateVersionInput, DeleteEnvironmentTemplateVersionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEnvironmentTemplateVersionCommandInput extends DeleteEnvironmentTemplateVersionInput {
-}
-export interface DeleteEnvironmentTemplateVersionCommandOutput extends DeleteEnvironmentTemplateVersionOutput, __MetadataBearer {
-}
-/**
- * <p>If no other minor versions of an environment template exist, delete a major version of the environment template if it's not the
- *                 <code>Recommended</code> version. Delete the <code>Recommended</code> version of the environment template if no other major versions
- *             or minor versions of the environment template exist. A major version of an environment template is a version that's not backwards
- *             compatible.</p>
- *         <p>Delete a minor version of an environment template if it <i>isn't</i> the <code>Recommended</code> version. Delete a
- *                 <code>Recommended</code> minor version of the environment template if no other minor versions of the environment template exist. A
- *             minor version of an environment template is a version that's backwards compatible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteEnvironmentTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteEnvironmentTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteEnvironmentTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEnvironmentTemplateVersionCommand extends $Command<DeleteEnvironmentTemplateVersionCommandInput, DeleteEnvironmentTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteEnvironmentTemplateVersionCommandInput;
-    constructor(input: DeleteEnvironmentTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentTemplateVersionCommandInput, DeleteEnvironmentTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteServiceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteServiceInput, DeleteServiceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteServiceCommandInput extends DeleteServiceInput {
-}
-export interface DeleteServiceCommandOutput extends DeleteServiceOutput, __MetadataBearer {
-}
-/**
- * <p>Delete a service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteServiceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteServiceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteServiceCommandInput} for command's `input` shape.
- * @see {@link DeleteServiceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteServiceCommand extends $Command<DeleteServiceCommandInput, DeleteServiceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteServiceCommandInput;
-    constructor(input: DeleteServiceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceCommandInput, DeleteServiceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteServiceTemplateCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteServiceTemplateInput, DeleteServiceTemplateOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteServiceTemplateCommandInput extends DeleteServiceTemplateInput {
-}
-export interface DeleteServiceTemplateCommandOutput extends DeleteServiceTemplateOutput, __MetadataBearer {
-}
-/**
- * <p>If no other major or minor versions of the service template exist, delete the service template.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteServiceTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteServiceTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteServiceTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteServiceTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteServiceTemplateCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteServiceTemplateCommand extends $Command<DeleteServiceTemplateCommandInput, DeleteServiceTemplateCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteServiceTemplateCommandInput;
-    constructor(input: DeleteServiceTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceTemplateCommandInput, DeleteServiceTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteServiceTemplateVersionCommand.d.ts

@@ -1,41 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { DeleteServiceTemplateVersionInput, DeleteServiceTemplateVersionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteServiceTemplateVersionCommandInput extends DeleteServiceTemplateVersionInput {
-}
-export interface DeleteServiceTemplateVersionCommandOutput extends DeleteServiceTemplateVersionOutput, __MetadataBearer {
-}
-/**
- * <p>If no other minor versions of a service template exist, delete a major version of the service template if it's not the
- *                 <code>Recommended</code> version. Delete the <code>Recommended</code> version of the service template if no other major versions or
- *             minor versions of the service template exist. A major version of a service template is a version that <i>isn't</i> backwards
- *             compatible.</p>
- *         <p>Delete a minor version of a service template if it's not the <code>Recommended</code> version. Delete a <code>Recommended</code> minor
- *             version of the service template if no other minor versions of the service template exist. A minor version of a service template is a
- *             version that's backwards compatible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, DeleteServiceTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, DeleteServiceTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new DeleteServiceTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteServiceTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteServiceTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteServiceTemplateVersionCommand extends $Command<DeleteServiceTemplateVersionCommandInput, DeleteServiceTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: DeleteServiceTemplateVersionCommandInput;
-    constructor(input: DeleteServiceTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceTemplateVersionCommandInput, DeleteServiceTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetAccountSettingsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetAccountSettingsInput, GetAccountSettingsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetAccountSettingsCommandInput extends GetAccountSettingsInput {
-}
-export interface GetAccountSettingsCommandOutput extends GetAccountSettingsOutput, __MetadataBearer {
-}
-/**
- * <p>Get detail data for the AWS Proton pipeline service role.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetAccountSettingsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetAccountSettingsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetAccountSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountSettingsCommandInput} for command's `input` shape.
- * @see {@link GetAccountSettingsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetAccountSettingsCommand extends $Command<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetAccountSettingsCommandInput;
-    constructor(input: GetAccountSettingsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetEnvironmentAccountConnectionCommand.d.ts

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetEnvironmentAccountConnectionInput, GetEnvironmentAccountConnectionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetEnvironmentAccountConnectionCommandInput extends GetEnvironmentAccountConnectionInput {
-}
-export interface GetEnvironmentAccountConnectionCommandOutput extends GetEnvironmentAccountConnectionOutput, __MetadataBearer {
-}
-/**
- * <p>In an environment account, view the detail data for an environment account 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, GetEnvironmentAccountConnectionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetEnvironmentAccountConnectionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetEnvironmentAccountConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEnvironmentAccountConnectionCommandInput} for command's `input` shape.
- * @see {@link GetEnvironmentAccountConnectionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetEnvironmentAccountConnectionCommand extends $Command<GetEnvironmentAccountConnectionCommandInput, GetEnvironmentAccountConnectionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetEnvironmentAccountConnectionCommandInput;
-    constructor(input: GetEnvironmentAccountConnectionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEnvironmentAccountConnectionCommandInput, GetEnvironmentAccountConnectionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetEnvironmentCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetEnvironmentInput, GetEnvironmentOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetEnvironmentCommandInput extends GetEnvironmentInput {
-}
-export interface GetEnvironmentCommandOutput extends GetEnvironmentOutput, __MetadataBearer {
-}
-/**
- * <p>Get detail data for an environment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetEnvironmentCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetEnvironmentCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEnvironmentCommandInput} for command's `input` shape.
- * @see {@link GetEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetEnvironmentCommand extends $Command<GetEnvironmentCommandInput, GetEnvironmentCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetEnvironmentCommandInput;
-    constructor(input: GetEnvironmentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEnvironmentCommandInput, GetEnvironmentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetEnvironmentTemplateCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetEnvironmentTemplateInput, GetEnvironmentTemplateOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetEnvironmentTemplateCommandInput extends GetEnvironmentTemplateInput {
-}
-export interface GetEnvironmentTemplateCommandOutput extends GetEnvironmentTemplateOutput, __MetadataBearer {
-}
-/**
- * <p>Get detail data for an environment template.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetEnvironmentTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetEnvironmentTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetEnvironmentTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEnvironmentTemplateCommandInput} for command's `input` shape.
- * @see {@link GetEnvironmentTemplateCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetEnvironmentTemplateCommand extends $Command<GetEnvironmentTemplateCommandInput, GetEnvironmentTemplateCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetEnvironmentTemplateCommandInput;
-    constructor(input: GetEnvironmentTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEnvironmentTemplateCommandInput, GetEnvironmentTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetEnvironmentTemplateVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetEnvironmentTemplateVersionInput, GetEnvironmentTemplateVersionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetEnvironmentTemplateVersionCommandInput extends GetEnvironmentTemplateVersionInput {
-}
-export interface GetEnvironmentTemplateVersionCommandOutput extends GetEnvironmentTemplateVersionOutput, __MetadataBearer {
-}
-/**
- * <p>View detail data for a major or minor version of an environment template.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetEnvironmentTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetEnvironmentTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetEnvironmentTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEnvironmentTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link GetEnvironmentTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetEnvironmentTemplateVersionCommand extends $Command<GetEnvironmentTemplateVersionCommandInput, GetEnvironmentTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetEnvironmentTemplateVersionCommandInput;
-    constructor(input: GetEnvironmentTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEnvironmentTemplateVersionCommandInput, GetEnvironmentTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}