@aws-sdk/client-proton 3.34.0 → 3.37.0

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

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateEnvironmentAccountConnectionInput, UpdateEnvironmentAccountConnectionOutput } 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 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

@@ -1,80 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateEnvironmentInput, UpdateEnvironmentOutput } 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 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

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateEnvironmentTemplateInput, UpdateEnvironmentTemplateOutput } 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 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

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateEnvironmentTemplateVersionInput, UpdateEnvironmentTemplateVersionOutput } 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 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

@@ -1,41 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateServiceInput, UpdateServiceOutput } 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 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

@@ -1,73 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateServiceInstanceInput, UpdateServiceInstanceOutput } 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 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

@@ -1,73 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateServicePipelineInput, UpdateServicePipelineOutput } 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 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

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateServiceTemplateInput, UpdateServiceTemplateOutput } 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 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

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateServiceTemplateVersionInput, UpdateServiceTemplateVersionOutput } 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 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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