@aws-sdk/client-proton 3.34.0 → 3.37.0

package/dist-types/commands/UpdateEnvironmentAccountConnectionCommand.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 { UpdateEnvironmentAccountConnectionInput, UpdateEnvironmentAccountConnectionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateEnvironmentAccountConnectionCommandInput extends UpdateEnvironmentAccountConnectionInput {
+}
+export interface UpdateEnvironmentAccountConnectionCommandOutput extends UpdateEnvironmentAccountConnectionOutput, __MetadataBearer {
+}
+/**
+ * <p>In an environment account, update an environment account connection to use a new IAM role.</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, UpdateEnvironmentAccountConnectionCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateEnvironmentAccountConnectionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateEnvironmentAccountConnectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEnvironmentAccountConnectionCommandInput} for command's `input` shape.
+ * @see {@link UpdateEnvironmentAccountConnectionCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateEnvironmentAccountConnectionCommand extends $Command<UpdateEnvironmentAccountConnectionCommandInput, UpdateEnvironmentAccountConnectionCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateEnvironmentAccountConnectionCommandInput;
+    constructor(input: UpdateEnvironmentAccountConnectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEnvironmentAccountConnectionCommandInput, UpdateEnvironmentAccountConnectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,80 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateEnvironmentInput, UpdateEnvironmentOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateEnvironmentCommandInput extends UpdateEnvironmentInput {
+}
+export interface UpdateEnvironmentCommandOutput extends UpdateEnvironmentOutput, __MetadataBearer {
+}
+/**
+ * <p>Update an environment.</p>
+ *         <p>If the environment is associated with an environment account connection, <i>don't</i> update or include the
+ *                 <code>protonServiceRoleArn</code> parameter to update or connect to an environment account connection. </p>
+ *         <p>You can only update to a new environment account connection if it was created in the same environment account that the current
+ *             environment account connection was created in and is associated with the current environment.</p>
+ *         <p>If the environment <i>isn't</i> associated with an environment account connection, <i>don't</i> update or
+ *             include the <code>environmentAccountConnectionId</code> parameter to update or connect to an environment account connection.</p>
+ *         <p>You can update either the <code>environmentAccountConnectionId</code> or <code>protonServiceRoleArn</code> parameter and value. You
+ *             can’t update both.</p>
+ *         <p>There are four modes for updating an environment as described in the following. The <code>deploymentType</code> field defines the
+ *             mode.</p>
+ *         <dl>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>NONE</code>
+ *                </p>
+ *                     <p>In this mode, a deployment <i>doesn't</i> occur. Only the requested metadata parameters are updated.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>CURRENT_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the environment is deployed and updated with the new spec that you provide. Only requested parameters are
+ *                         updated. <i>Don’t</i> include minor or major version parameters when you use this
+ *                         <code>deployment-type</code>.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MINOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the environment is deployed and updated with the published, recommended (latest) minor version of the current
+ *                         major version in use, by default. You can also specify a different minor version of the current major version in use.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MAJOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the environment is deployed and updated with the published, recommended (latest) major and minor version of
+ *                         the current template, by default. You can also specify a different major version that's higher than the major version in use
+ *                         and a minor version (optional).</p>
+ *                 </dd>
+ *          </dl>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateEnvironmentCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateEnvironmentCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link UpdateEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateEnvironmentCommand extends $Command<UpdateEnvironmentCommandInput, UpdateEnvironmentCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateEnvironmentCommandInput;
+    constructor(input: UpdateEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEnvironmentCommandInput, UpdateEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateEnvironmentTemplateCommand.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 { UpdateEnvironmentTemplateInput, UpdateEnvironmentTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateEnvironmentTemplateCommandInput extends UpdateEnvironmentTemplateInput {
+}
+export interface UpdateEnvironmentTemplateCommandOutput extends UpdateEnvironmentTemplateOutput, __MetadataBearer {
+}
+/**
+ * <p>Update an environment template.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateEnvironmentTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateEnvironmentTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateEnvironmentTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEnvironmentTemplateCommandInput} for command's `input` shape.
+ * @see {@link UpdateEnvironmentTemplateCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateEnvironmentTemplateCommand extends $Command<UpdateEnvironmentTemplateCommandInput, UpdateEnvironmentTemplateCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateEnvironmentTemplateCommandInput;
+    constructor(input: UpdateEnvironmentTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEnvironmentTemplateCommandInput, UpdateEnvironmentTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateEnvironmentTemplateVersionCommand.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 { UpdateEnvironmentTemplateVersionInput, UpdateEnvironmentTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateEnvironmentTemplateVersionCommandInput extends UpdateEnvironmentTemplateVersionInput {
+}
+export interface UpdateEnvironmentTemplateVersionCommandOutput extends UpdateEnvironmentTemplateVersionOutput, __MetadataBearer {
+}
+/**
+ * <p>Update 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, UpdateEnvironmentTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateEnvironmentTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateEnvironmentTemplateVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEnvironmentTemplateVersionCommandInput} for command's `input` shape.
+ * @see {@link UpdateEnvironmentTemplateVersionCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateEnvironmentTemplateVersionCommand extends $Command<UpdateEnvironmentTemplateVersionCommandInput, UpdateEnvironmentTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateEnvironmentTemplateVersionCommandInput;
+    constructor(input: UpdateEnvironmentTemplateVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEnvironmentTemplateVersionCommandInput, UpdateEnvironmentTemplateVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateServiceCommand.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 { UpdateServiceInput, UpdateServiceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateServiceCommandInput extends UpdateServiceInput {
+}
+export interface UpdateServiceCommandOutput extends UpdateServiceOutput, __MetadataBearer {
+}
+/**
+ * <p>Edit a service description or use a spec to add and delete service instances.</p>
+ *         <note>
+ *             <p>Existing service instances and the service pipeline <i>can't</i> be edited using this API. They can only be
+ *                 deleted.</p>
+ *         </note>
+ *         <p>Use the <code>description</code> parameter to modify the description.</p>
+ *         <p>Edit the <code>spec</code> parameter to add or delete instances.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateServiceCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateServiceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateServiceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateServiceCommandInput} for command's `input` shape.
+ * @see {@link UpdateServiceCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateServiceCommand extends $Command<UpdateServiceCommandInput, UpdateServiceCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateServiceCommandInput;
+    constructor(input: UpdateServiceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceCommandInput, UpdateServiceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,73 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateServiceInstanceInput, UpdateServiceInstanceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateServiceInstanceCommandInput extends UpdateServiceInstanceInput {
+}
+export interface UpdateServiceInstanceCommandOutput extends UpdateServiceInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Update a service instance.</p>
+ *         <p>There are four modes for updating a service instance as described in the following. The <code>deploymentType</code> field defines the
+ *             mode.</p>
+ *         <dl>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>NONE</code>
+ *                </p>
+ *                     <p>In this mode, a deployment <i>doesn't</i> occur. Only the requested metadata parameters are updated.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>CURRENT_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service instance is deployed and updated with the new spec that you provide. Only requested parameters are
+ *                         updated. <i>Don’t</i> include minor or major version parameters when you use this
+ *                         <code>deployment-type</code>.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MINOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service instance is deployed and updated with the published, recommended (latest) minor version of the
+ *                         current major version in use, by default. You can also specify a different minor version of the current major version in
+ *                         use.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MAJOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service instance is deployed and updated with the published, recommended (latest) major and minor version
+ *                         of the current template, by default. You can also specify a different major version that is higher than the major version in
+ *                         use and a minor version (optional).</p>
+ *                 </dd>
+ *          </dl>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateServiceInstanceCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateServiceInstanceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateServiceInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateServiceInstanceCommandInput} for command's `input` shape.
+ * @see {@link UpdateServiceInstanceCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateServiceInstanceCommand extends $Command<UpdateServiceInstanceCommandInput, UpdateServiceInstanceCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateServiceInstanceCommandInput;
+    constructor(input: UpdateServiceInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceInstanceCommandInput, UpdateServiceInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,73 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateServicePipelineInput, UpdateServicePipelineOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateServicePipelineCommandInput extends UpdateServicePipelineInput {
+}
+export interface UpdateServicePipelineCommandOutput extends UpdateServicePipelineOutput, __MetadataBearer {
+}
+/**
+ * <p>Update the service pipeline.</p>
+ *         <p>There are four modes for updating a service pipeline as described in the following. The <code>deploymentType</code> field defines the
+ *             mode.</p>
+ *         <dl>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>NONE</code>
+ *                </p>
+ *                     <p>In this mode, a deployment <i>doesn't</i> occur. Only the requested metadata parameters are updated.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>CURRENT_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service pipeline is deployed and updated with the new spec that you provide. Only requested parameters are
+ *                         updated. <i>Don’t</i> include minor or major version parameters when you use this
+ *                         <code>deployment-type</code>.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MINOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service pipeline is deployed and updated with the published, recommended (latest) minor version of the
+ *                         current major version in use, by default. You can also specify a different minor version of the current major version in
+ *                         use.</p>
+ *                 </dd>
+ *             <dt/>
+ *             <dd>
+ *                     <p>
+ *                   <code>MAJOR_VERSION</code>
+ *                </p>
+ *                     <p>In this mode, the service pipeline is deployed and updated with the published, recommended (latest) major and minor version
+ *                         of the current template by default. You can also specify a different major version that is higher than the major version in
+ *                         use and a minor version (optional).</p>
+ *                 </dd>
+ *          </dl>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateServicePipelineCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateServicePipelineCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateServicePipelineCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateServicePipelineCommandInput} for command's `input` shape.
+ * @see {@link UpdateServicePipelineCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateServicePipelineCommand extends $Command<UpdateServicePipelineCommandInput, UpdateServicePipelineCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateServicePipelineCommandInput;
+    constructor(input: UpdateServicePipelineCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServicePipelineCommandInput, UpdateServicePipelineCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateServiceTemplateCommand.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 { UpdateServiceTemplateInput, UpdateServiceTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateServiceTemplateCommandInput extends UpdateServiceTemplateInput {
+}
+export interface UpdateServiceTemplateCommandOutput extends UpdateServiceTemplateOutput, __MetadataBearer {
+}
+/**
+ * <p>Update a service template.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateServiceTemplateCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateServiceTemplateCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateServiceTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateServiceTemplateCommandInput} for command's `input` shape.
+ * @see {@link UpdateServiceTemplateCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateServiceTemplateCommand extends $Command<UpdateServiceTemplateCommandInput, UpdateServiceTemplateCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateServiceTemplateCommandInput;
+    constructor(input: UpdateServiceTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceTemplateCommandInput, UpdateServiceTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateServiceTemplateVersionCommand.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 { UpdateServiceTemplateVersionInput, UpdateServiceTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface UpdateServiceTemplateVersionCommandInput extends UpdateServiceTemplateVersionInput {
+}
+export interface UpdateServiceTemplateVersionCommandOutput extends UpdateServiceTemplateVersionOutput, __MetadataBearer {
+}
+/**
+ * <p>Update a major or minor version of a service template.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, UpdateServiceTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, UpdateServiceTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new UpdateServiceTemplateVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateServiceTemplateVersionCommandInput} for command's `input` shape.
+ * @see {@link UpdateServiceTemplateVersionCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateServiceTemplateVersionCommand extends $Command<UpdateServiceTemplateVersionCommandInput, UpdateServiceTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: UpdateServiceTemplateVersionCommandInput;
+    constructor(input: UpdateServiceTemplateVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceTemplateVersionCommandInput, UpdateServiceTemplateVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+export interface ProtonPaginationConfiguration extends PaginationConfiguration {
+    client: Proton | ProtonClient;
+}

package/dist-types/pagination/ListEnvironmentAccountConnectionsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListEnvironmentAccountConnectionsCommandInput, ListEnvironmentAccountConnectionsCommandOutput } from "../commands/ListEnvironmentAccountConnectionsCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListEnvironmentAccountConnections(config: ProtonPaginationConfiguration, input: ListEnvironmentAccountConnectionsCommandInput, ...additionalArguments: any): Paginator<ListEnvironmentAccountConnectionsCommandOutput>;

package/dist-types/pagination/ListEnvironmentTemplateVersionsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListEnvironmentTemplateVersionsCommandInput, ListEnvironmentTemplateVersionsCommandOutput } from "../commands/ListEnvironmentTemplateVersionsCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListEnvironmentTemplateVersions(config: ProtonPaginationConfiguration, input: ListEnvironmentTemplateVersionsCommandInput, ...additionalArguments: any): Paginator<ListEnvironmentTemplateVersionsCommandOutput>;

package/dist-types/pagination/ListEnvironmentTemplatesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListEnvironmentTemplatesCommandInput, ListEnvironmentTemplatesCommandOutput } from "../commands/ListEnvironmentTemplatesCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListEnvironmentTemplates(config: ProtonPaginationConfiguration, input: ListEnvironmentTemplatesCommandInput, ...additionalArguments: any): Paginator<ListEnvironmentTemplatesCommandOutput>;

package/dist-types/pagination/ListEnvironmentsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListEnvironmentsCommandInput, ListEnvironmentsCommandOutput } from "../commands/ListEnvironmentsCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListEnvironments(config: ProtonPaginationConfiguration, input: ListEnvironmentsCommandInput, ...additionalArguments: any): Paginator<ListEnvironmentsCommandOutput>;

package/dist-types/pagination/ListServiceInstancesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListServiceInstancesCommandInput, ListServiceInstancesCommandOutput } from "../commands/ListServiceInstancesCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListServiceInstances(config: ProtonPaginationConfiguration, input: ListServiceInstancesCommandInput, ...additionalArguments: any): Paginator<ListServiceInstancesCommandOutput>;

package/dist-types/pagination/ListServiceTemplateVersionsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListServiceTemplateVersionsCommandInput, ListServiceTemplateVersionsCommandOutput } from "../commands/ListServiceTemplateVersionsCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListServiceTemplateVersions(config: ProtonPaginationConfiguration, input: ListServiceTemplateVersionsCommandInput, ...additionalArguments: any): Paginator<ListServiceTemplateVersionsCommandOutput>;

package/dist-types/pagination/ListServiceTemplatesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListServiceTemplatesCommandInput, ListServiceTemplatesCommandOutput } from "../commands/ListServiceTemplatesCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListServiceTemplates(config: ProtonPaginationConfiguration, input: ListServiceTemplatesCommandInput, ...additionalArguments: any): Paginator<ListServiceTemplatesCommandOutput>;

package/dist-types/pagination/ListServicesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListServicesCommandInput, ListServicesCommandOutput } from "../commands/ListServicesCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListServices(config: ProtonPaginationConfiguration, input: ListServicesCommandInput, ...additionalArguments: any): Paginator<ListServicesCommandOutput>;

package/dist-types/pagination/ListTagsForResourcePaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "../commands/ListTagsForResourceCommand";
+import { ProtonPaginationConfiguration } from "./Interfaces";
+export declare function paginateListTagsForResource(config: ProtonPaginationConfiguration, input: ListTagsForResourceCommandInput, ...additionalArguments: any): Paginator<ListTagsForResourceCommandOutput>;