@aws-sdk/client-proton 3.34.0 → 3.37.0

package/dist-types/commands/GetServiceCommand.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 { GetServiceInput, GetServiceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/GetServiceInstanceCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetServiceInstanceInput, GetServiceInstanceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/GetServiceTemplateCommand.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 { GetServiceTemplateInput, GetServiceTemplateOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/GetServiceTemplateVersionCommand.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 { GetServiceTemplateVersionInput, GetServiceTemplateVersionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListEnvironmentAccountConnectionsCommand.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 { ListEnvironmentAccountConnectionsInput, ListEnvironmentAccountConnectionsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListEnvironmentTemplateVersionsCommand.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 { ListEnvironmentTemplateVersionsInput, ListEnvironmentTemplateVersionsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListEnvironmentTemplatesCommand.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 { ListEnvironmentTemplatesInput, ListEnvironmentTemplatesOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListEnvironmentsCommand.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 { ListEnvironmentsInput, ListEnvironmentsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListServiceInstancesCommand.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 { ListServiceInstancesInput, ListServiceInstancesOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListServiceTemplateVersionsCommand.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 { ListServiceTemplateVersionsInput, ListServiceTemplateVersionsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListServiceTemplatesCommand.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 { ListServiceTemplatesInput, ListServiceTemplatesOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListServicesCommand.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 { ListServicesInput, ListServicesOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/ListTagsForResourceCommand.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 { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/RejectEnvironmentAccountConnectionCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RejectEnvironmentAccountConnectionInput, RejectEnvironmentAccountConnectionOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/TagResourceCommand.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 { TagResourceInput, TagResourceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/UntagResourceCommand.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 { UntagResourceInput, UntagResourceOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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/commands/UpdateAccountSettingsCommand.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 { UpdateAccountSettingsInput, UpdateAccountSettingsOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+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;
+}