@aws-sdk/client-proton 3.41.0 → 3.46.0

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

@@ -7,9 +7,8 @@ export interface CreateServiceTemplateVersionCommandInput extends CreateServiceT
 export interface CreateServiceTemplateVersionCommandOutput extends CreateServiceTemplateVersionOutput, __MetadataBearer {
 }
 /**
- * <p>Create a new major or minor version of a service template. A major version of a service template is a version that
- *                 <i>isn't</i> backwards compatible. A minor version of a service template is a version that's backwards compatible within
- *             its major version.</p>
+ * <p>Create a new major or minor version of a service template. A major version of a service template is a version that <i>isn't</i>
+ *    backward compatible. A minor version of a service template is a version that's backward compatible within its major version.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateTemplateSyncConfigInput, CreateTemplateSyncConfigOutput } from "../models/models_0";
+import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
+export interface CreateTemplateSyncConfigCommandInput extends CreateTemplateSyncConfigInput {
+}
+export interface CreateTemplateSyncConfigCommandOutput extends CreateTemplateSyncConfigOutput, __MetadataBearer {
+}
+/**
+ * <p>Set up a template for automated template version creation. When a commit is pushed to your registered <a href="https://docs.aws.amazon.com/proton/latest/APIReference/API_Repository.html">repository</a>, Proton checks for changes to your repository template bundles. If it
+ *    detects a template bundle change, a new minor or major version of its template is created, if the version doesn’t already exist. For more
+ *    information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-template-sync-configs.html">Template sync configurations</a> in
+ *    the <i>Proton Administrator Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ProtonClient, CreateTemplateSyncConfigCommand } from "@aws-sdk/client-proton"; // ES Modules import
+ * // const { ProtonClient, CreateTemplateSyncConfigCommand } = require("@aws-sdk/client-proton"); // CommonJS import
+ * const client = new ProtonClient(config);
+ * const command = new CreateTemplateSyncConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTemplateSyncConfigCommandInput} for command's `input` shape.
+ * @see {@link CreateTemplateSyncConfigCommandOutput} for command's `response` shape.
+ * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
+ *
+ */
+export declare class CreateTemplateSyncConfigCommand extends $Command<CreateTemplateSyncConfigCommandInput, CreateTemplateSyncConfigCommandOutput, ProtonClientResolvedConfig> {
+    readonly input: CreateTemplateSyncConfigCommandInput;
+    constructor(input: CreateTemplateSyncConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTemplateSyncConfigCommandInput, CreateTemplateSyncConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -8,11 +8,11 @@ export interface DeleteEnvironmentAccountConnectionCommandOutput extends DeleteE
 }
 /**
  * <p>In an environment account, delete an environment account connection.</p>
- *         <p>After you delete an environment account connection that’s in use by an AWS Proton environment, AWS Proton <i>can’t</i>
- *             manage the environment infrastructure resources until a new environment account connection is accepted for the environment account and
- *             associated environment. You're responsible for cleaning up provisioned resources that remain without an environment connection.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-account-connections.html">Environment account
- *                 connections</a> in the <i>AWS Proton Administrator guide</i>.</p>
+ *          <p>After you delete an environment account connection that’s in use by an Proton environment, Proton <i>can’t</i> manage the
+ *    environment infrastructure resources until a new environment account connection is accepted for the environment account and associated environment.
+ *    You're responsible for cleaning up provisioned resources that remain without an environment connection.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-account-connections.html">Environment account
+ *     connections</a> in the <i>Proton Administrator guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -8,12 +8,11 @@ export interface DeleteEnvironmentTemplateVersionCommandOutput extends DeleteEnv
 }
 /**
  * <p>If no other minor versions of an environment template exist, delete a major version of the environment template if it's not the
- *                 <code>Recommended</code> version. Delete the <code>Recommended</code> version of the environment template if no other major versions
- *             or minor versions of the environment template exist. A major version of an environment template is a version that's not backwards
- *             compatible.</p>
- *         <p>Delete a minor version of an environment template if it <i>isn't</i> the <code>Recommended</code> version. Delete a
- *                 <code>Recommended</code> minor version of the environment template if no other minor versions of the environment template exist. A
- *             minor version of an environment template is a version that's backwards compatible.</p>
+ *     <code>Recommended</code> version. Delete the <code>Recommended</code> version of the environment template if no other major versions or minor
+ *    versions of the environment template exist. A major version of an environment template is a version that's not backward compatible.</p>
+ *          <p>Delete a minor version of an environment template if it <i>isn't</i> the <code>Recommended</code> version. Delete a
+ *     <code>Recommended</code> minor version of the environment template if no other minor versions of the environment template exist. A minor version
+ *    of an environment template is a version that's backward compatible.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

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

@@ -8,12 +8,11 @@ export interface DeleteServiceTemplateVersionCommandOutput extends DeleteService
 }
 /**
  * <p>If no other minor versions of a service template exist, delete a major version of the service template if it's not the
- *                 <code>Recommended</code> version. Delete the <code>Recommended</code> version of the service template if no other major versions or
- *             minor versions of the service template exist. A major version of a service template is a version that <i>isn't</i> backwards
- *             compatible.</p>
- *         <p>Delete a minor version of a service template if it's not the <code>Recommended</code> version. Delete a <code>Recommended</code> minor
- *             version of the service template if no other minor versions of the service template exist. A minor version of a service template is a
- *             version that's backwards compatible.</p>
+ *     <code>Recommended</code> version. Delete the <code>Recommended</code> version of the service template if no other major versions or minor versions
+ *    of the service template exist. A major version of a service template is a version that <i>isn't</i> backwards compatible.</p>
+ *          <p>Delete a minor version of a service template if it's not the <code>Recommended</code> version. Delete a <code>Recommended</code> minor version
+ *    of the service template if no other minor versions of the service template exist. A minor version of a service template is a version that's
+ *    backwards compatible.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

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

@@ -7,7 +7,7 @@ export interface GetAccountSettingsCommandInput extends GetAccountSettingsInput
 export interface GetAccountSettingsCommandOutput extends GetAccountSettingsOutput, __MetadataBearer {
 }
 /**
- * <p>Get detail data for the AWS Proton pipeline service role.</p>
+ * <p>Get detail data for the Proton pipeline service role.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -8,8 +8,8 @@ export interface GetEnvironmentAccountConnectionCommandOutput extends GetEnviron
 }
 /**
  * <p>In an environment account, view the detail data for an environment account connection.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-account-connections.html">Environment account
- *                 connections</a> in the <i>AWS Proton Administrator guide</i>.</p>
+ *          <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>Proton Administrator guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

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

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

@@ -8,7 +8,7 @@ export interface GetServiceInstanceCommandOutput extends GetServiceInstanceOutpu
 }
 /**
  * <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>
+ *    environment.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

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

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

@@ -8,8 +8,8 @@ export interface ListEnvironmentAccountConnectionsCommandOutput extends ListEnvi
 }
 /**
  * <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>
+ *          <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>Proton Administrator guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

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

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

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

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

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