@aws-sdk/client-proton 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/GetServiceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetServiceInput, GetServiceOutput } 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 GetServiceCommandInput extends GetServiceInput {
-}
-export interface GetServiceCommandOutput extends GetServiceOutput, __MetadataBearer {
-}
-/**
- * <p>Get detail data for a service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetServiceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetServiceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetServiceCommandInput} for command's `input` shape.
- * @see {@link GetServiceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetServiceCommand extends $Command<GetServiceCommandInput, GetServiceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetServiceCommandInput;
-    constructor(input: GetServiceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServiceCommandInput, GetServiceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetServiceInstanceCommand.d.ts

@@ -1,36 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetServiceInstanceInput, GetServiceInstanceOutput } 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 GetServiceInstanceCommandInput extends GetServiceInstanceInput {
-}
-export interface GetServiceInstanceCommandOutput extends GetServiceInstanceOutput, __MetadataBearer {
-}
-/**
- * <p>Get detail data for a service instance. A service instance is an instantiation of service template, which is running in a specific
- *             environment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, GetServiceInstanceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetServiceInstanceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetServiceInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetServiceInstanceCommandInput} for command's `input` shape.
- * @see {@link GetServiceInstanceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetServiceInstanceCommand extends $Command<GetServiceInstanceCommandInput, GetServiceInstanceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetServiceInstanceCommandInput;
-    constructor(input: GetServiceInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServiceInstanceCommandInput, GetServiceInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetServiceTemplateCommand.d.ts

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

package/dist/types/ts3.4/commands/GetServiceTemplateVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { GetServiceTemplateVersionInput, GetServiceTemplateVersionOutput } 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 GetServiceTemplateVersionCommandInput extends GetServiceTemplateVersionInput {
-}
-export interface GetServiceTemplateVersionCommandOutput extends GetServiceTemplateVersionOutput, __MetadataBearer {
-}
-/**
- * <p>View detail data for 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, GetServiceTemplateVersionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, GetServiceTemplateVersionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new GetServiceTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetServiceTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link GetServiceTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetServiceTemplateVersionCommand extends $Command<GetServiceTemplateVersionCommandInput, GetServiceTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: GetServiceTemplateVersionCommandInput;
-    constructor(input: GetServiceTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServiceTemplateVersionCommandInput, GetServiceTemplateVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListEnvironmentAccountConnectionsCommand.d.ts

@@ -1,37 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListEnvironmentAccountConnectionsInput, ListEnvironmentAccountConnectionsOutput } 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 ListEnvironmentAccountConnectionsCommandInput extends ListEnvironmentAccountConnectionsInput {
-}
-export interface ListEnvironmentAccountConnectionsCommandOutput extends ListEnvironmentAccountConnectionsOutput, __MetadataBearer {
-}
-/**
- * <p>View a list of environment account connections.</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, ListEnvironmentAccountConnectionsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListEnvironmentAccountConnectionsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListEnvironmentAccountConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEnvironmentAccountConnectionsCommandInput} for command's `input` shape.
- * @see {@link ListEnvironmentAccountConnectionsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEnvironmentAccountConnectionsCommand extends $Command<ListEnvironmentAccountConnectionsCommandInput, ListEnvironmentAccountConnectionsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListEnvironmentAccountConnectionsCommandInput;
-    constructor(input: ListEnvironmentAccountConnectionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEnvironmentAccountConnectionsCommandInput, ListEnvironmentAccountConnectionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListEnvironmentTemplateVersionsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListEnvironmentTemplateVersionsInput, ListEnvironmentTemplateVersionsOutput } 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 ListEnvironmentTemplateVersionsCommandInput extends ListEnvironmentTemplateVersionsInput {
-}
-export interface ListEnvironmentTemplateVersionsCommandOutput extends ListEnvironmentTemplateVersionsOutput, __MetadataBearer {
-}
-/**
- * <p>List major or minor versions of an environment template with detail data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListEnvironmentTemplateVersionsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListEnvironmentTemplateVersionsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListEnvironmentTemplateVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEnvironmentTemplateVersionsCommandInput} for command's `input` shape.
- * @see {@link ListEnvironmentTemplateVersionsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEnvironmentTemplateVersionsCommand extends $Command<ListEnvironmentTemplateVersionsCommandInput, ListEnvironmentTemplateVersionsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListEnvironmentTemplateVersionsCommandInput;
-    constructor(input: ListEnvironmentTemplateVersionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEnvironmentTemplateVersionsCommandInput, ListEnvironmentTemplateVersionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListEnvironmentTemplatesCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListEnvironmentTemplatesInput, ListEnvironmentTemplatesOutput } 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 ListEnvironmentTemplatesCommandInput extends ListEnvironmentTemplatesInput {
-}
-export interface ListEnvironmentTemplatesCommandOutput extends ListEnvironmentTemplatesOutput, __MetadataBearer {
-}
-/**
- * <p>List environment templates.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListEnvironmentTemplatesCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListEnvironmentTemplatesCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListEnvironmentTemplatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEnvironmentTemplatesCommandInput} for command's `input` shape.
- * @see {@link ListEnvironmentTemplatesCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEnvironmentTemplatesCommand extends $Command<ListEnvironmentTemplatesCommandInput, ListEnvironmentTemplatesCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListEnvironmentTemplatesCommandInput;
-    constructor(input: ListEnvironmentTemplatesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEnvironmentTemplatesCommandInput, ListEnvironmentTemplatesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListEnvironmentsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListEnvironmentsInput, ListEnvironmentsOutput } 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 ListEnvironmentsCommandInput extends ListEnvironmentsInput {
-}
-export interface ListEnvironmentsCommandOutput extends ListEnvironmentsOutput, __MetadataBearer {
-}
-/**
- * <p>List environments with detail data summaries.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListEnvironmentsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListEnvironmentsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListEnvironmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEnvironmentsCommandInput} for command's `input` shape.
- * @see {@link ListEnvironmentsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListEnvironmentsCommand extends $Command<ListEnvironmentsCommandInput, ListEnvironmentsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListEnvironmentsCommandInput;
-    constructor(input: ListEnvironmentsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEnvironmentsCommandInput, ListEnvironmentsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListServiceInstancesCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListServiceInstancesInput, ListServiceInstancesOutput } 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 ListServiceInstancesCommandInput extends ListServiceInstancesInput {
-}
-export interface ListServiceInstancesCommandOutput extends ListServiceInstancesOutput, __MetadataBearer {
-}
-/**
- * <p>List service instances with summaries of detail data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListServiceInstancesCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListServiceInstancesCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListServiceInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServiceInstancesCommandInput} for command's `input` shape.
- * @see {@link ListServiceInstancesCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListServiceInstancesCommand extends $Command<ListServiceInstancesCommandInput, ListServiceInstancesCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListServiceInstancesCommandInput;
-    constructor(input: ListServiceInstancesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServiceInstancesCommandInput, ListServiceInstancesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListServiceTemplateVersionsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListServiceTemplateVersionsInput, ListServiceTemplateVersionsOutput } 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 ListServiceTemplateVersionsCommandInput extends ListServiceTemplateVersionsInput {
-}
-export interface ListServiceTemplateVersionsCommandOutput extends ListServiceTemplateVersionsOutput, __MetadataBearer {
-}
-/**
- * <p>List major or minor versions of a service template with detail data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListServiceTemplateVersionsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListServiceTemplateVersionsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListServiceTemplateVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServiceTemplateVersionsCommandInput} for command's `input` shape.
- * @see {@link ListServiceTemplateVersionsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListServiceTemplateVersionsCommand extends $Command<ListServiceTemplateVersionsCommandInput, ListServiceTemplateVersionsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListServiceTemplateVersionsCommandInput;
-    constructor(input: ListServiceTemplateVersionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServiceTemplateVersionsCommandInput, ListServiceTemplateVersionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListServiceTemplatesCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListServiceTemplatesInput, ListServiceTemplatesOutput } 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 ListServiceTemplatesCommandInput extends ListServiceTemplatesInput {
-}
-export interface ListServiceTemplatesCommandOutput extends ListServiceTemplatesOutput, __MetadataBearer {
-}
-/**
- * <p>List service templates with detail data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListServiceTemplatesCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListServiceTemplatesCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListServiceTemplatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServiceTemplatesCommandInput} for command's `input` shape.
- * @see {@link ListServiceTemplatesCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListServiceTemplatesCommand extends $Command<ListServiceTemplatesCommandInput, ListServiceTemplatesCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListServiceTemplatesCommandInput;
-    constructor(input: ListServiceTemplatesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServiceTemplatesCommandInput, ListServiceTemplatesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListServicesCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListServicesInput, ListServicesOutput } 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 ListServicesCommandInput extends ListServicesInput {
-}
-export interface ListServicesCommandOutput extends ListServicesOutput, __MetadataBearer {
-}
-/**
- * <p>List services with summaries of detail data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListServicesCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListServicesCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListServicesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServicesCommandInput} for command's `input` shape.
- * @see {@link ListServicesCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListServicesCommand extends $Command<ListServicesCommandInput, ListServicesCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListServicesCommandInput;
-    constructor(input: ListServicesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServicesCommandInput, ListServicesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { ListTagsForResourceInput, ListTagsForResourceOutput } 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 ListTagsForResourceCommandInput extends ListTagsForResourceInput {
-}
-export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
-}
-/**
- * <p>List tags for a resource. For more information, see <i>AWS Proton resources and tagging</i> in the <a href="https://docs.aws.amazon.com/proton/latest/adminguide/resources.html">AWS Proton Administrator Guide</a> or <a href="https://docs.aws.amazon.com/proton/latest/userguide/resources.html">AWS Proton User Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, ListTagsForResourceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, ListTagsForResourceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: ListTagsForResourceCommandInput;
-    constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RejectEnvironmentAccountConnectionCommand.d.ts

@@ -1,40 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { RejectEnvironmentAccountConnectionInput, RejectEnvironmentAccountConnectionOutput } 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 RejectEnvironmentAccountConnectionCommandInput extends RejectEnvironmentAccountConnectionInput {
-}
-export interface RejectEnvironmentAccountConnectionCommandOutput extends RejectEnvironmentAccountConnectionOutput, __MetadataBearer {
-}
-/**
- * <p>In a management account, reject an environment account connection from another environment account.</p>
- *         <p>After you reject an environment account connection request, you <i>won’t</i> be able to accept or use the rejected
- *             environment account connection.</p>
- *         <p>You <i>can’t</i> reject an environment account connection that is connected to an environment.</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, RejectEnvironmentAccountConnectionCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, RejectEnvironmentAccountConnectionCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new RejectEnvironmentAccountConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RejectEnvironmentAccountConnectionCommandInput} for command's `input` shape.
- * @see {@link RejectEnvironmentAccountConnectionCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RejectEnvironmentAccountConnectionCommand extends $Command<RejectEnvironmentAccountConnectionCommandInput, RejectEnvironmentAccountConnectionCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: RejectEnvironmentAccountConnectionCommandInput;
-    constructor(input: RejectEnvironmentAccountConnectionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectEnvironmentAccountConnectionCommandInput, RejectEnvironmentAccountConnectionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { TagResourceInput, TagResourceOutput } 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 TagResourceCommandInput extends TagResourceInput {
-}
-export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataBearer {
-}
-/**
- * <p>Tag a resource. For more information, see <i>AWS Proton resources and tagging</i> in the <a href="https://docs.aws.amazon.com/proton/latest/adminguide/resources.html">AWS Proton Administrator Guide</a> or <a href="https://docs.aws.amazon.com/proton/latest/userguide/resources.html">AWS Proton User Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, TagResourceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, TagResourceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UntagResourceInput, UntagResourceOutput } 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 UntagResourceCommandInput extends UntagResourceInput {
-}
-export interface UntagResourceCommandOutput extends UntagResourceOutput, __MetadataBearer {
-}
-/**
- * <p>Remove a tag from a resource. For more information, see <i>AWS Proton resources and tagging</i> in the <a href="https://docs.aws.amazon.com/proton/latest/adminguide/resources.html">AWS Proton Administrator Guide</a> or <a href="https://docs.aws.amazon.com/proton/latest/userguide/resources.html">AWS Proton User Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, UntagResourceCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, UntagResourceCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: UntagResourceCommandInput;
-    constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateAccountSettingsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
-import { UpdateAccountSettingsInput, UpdateAccountSettingsOutput } 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 UpdateAccountSettingsCommandInput extends UpdateAccountSettingsInput {
-}
-export interface UpdateAccountSettingsCommandOutput extends UpdateAccountSettingsOutput, __MetadataBearer {
-}
-/**
- * <p>Update the AWS Proton pipeline service account settings.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ProtonClient, UpdateAccountSettingsCommand } from "@aws-sdk/client-proton"; // ES Modules import
- * // const { ProtonClient, UpdateAccountSettingsCommand } = require("@aws-sdk/client-proton"); // CommonJS import
- * const client = new ProtonClient(config);
- * const command = new UpdateAccountSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccountSettingsCommandInput} for command's `input` shape.
- * @see {@link UpdateAccountSettingsCommandOutput} for command's `response` shape.
- * @see {@link ProtonClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateAccountSettingsCommand extends $Command<UpdateAccountSettingsCommandInput, UpdateAccountSettingsCommandOutput, ProtonClientResolvedConfig> {
-    readonly input: UpdateAccountSettingsCommandInput;
-    constructor(input: UpdateAccountSettingsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccountSettingsCommandInput, UpdateAccountSettingsCommandOutput>;
-    private serialize;
-    private deserialize;
-}