@aws-sdk/client-proton 3.34.0 → 3.37.0

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateEnvironmentTemplateVersionInput, CreateEnvironmentTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateServiceInput, CreateServiceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateServiceTemplateInput, CreateServiceTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateServiceTemplateVersionInput, CreateServiceTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteEnvironmentAccountConnectionInput, DeleteEnvironmentAccountConnectionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteEnvironmentInput, DeleteEnvironmentOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteEnvironmentTemplateInput, DeleteEnvironmentTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteEnvironmentTemplateVersionInput, DeleteEnvironmentTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteServiceInput, DeleteServiceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteServiceTemplateInput, DeleteServiceTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteServiceTemplateVersionInput, DeleteServiceTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetAccountSettingsInput, GetAccountSettingsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEnvironmentAccountConnectionInput, GetEnvironmentAccountConnectionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEnvironmentInput, GetEnvironmentOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEnvironmentTemplateInput, GetEnvironmentTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEnvironmentTemplateVersionInput, GetEnvironmentTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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;
+}