@aws-sdk/client-proton 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateServiceInput, CreateServiceOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link CreateServiceCommand}.
  */
 export interface CreateServiceCommandInput extends CreateServiceInput {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateServiceCommand}.
  */
 export interface CreateServiceCommandOutput extends CreateServiceOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Create an Proton service. An Proton service is an instantiation of a service template and often includes several service instances and pipeline.
  *       For more information, see <a href="https://docs.aws.amazon.com/proton/latest/userguide/ag-services.html">Services</a> in the <i>Proton User
  *         Guide</i>.</p>
@@ -27,6 +32,8 @@ export interface CreateServiceCommandOutput extends CreateServiceOutput, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateServiceCommandInput - {@link CreateServiceCommandInput}
+ * @returns {@link CreateServiceCommandOutput}
  * @see {@link CreateServiceCommandInput} for command's `input` shape.
  * @see {@link CreateServiceCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -58,11 +65,20 @@ export interface CreateServiceCommandOutput extends CreateServiceOutput, __Metad
 export declare class CreateServiceCommand extends $Command<CreateServiceCommandInput, CreateServiceCommandOutput, ProtonClientResolvedConfig> {
     readonly input: CreateServiceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateServiceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceCommandInput, CreateServiceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateServiceTemplateInput, CreateServiceTemplateOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link CreateServiceTemplateCommand}.
  */
 export interface CreateServiceTemplateCommandInput extends CreateServiceTemplateInput {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateServiceTemplateCommand}.
  */
 export interface CreateServiceTemplateCommandOutput extends CreateServiceTemplateOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Create a service template. The administrator creates a service template to define standardized infrastructure and an optional CI/CD service pipeline.
  *       Developers, in turn, select the service template from Proton. If the selected service template includes a service pipeline definition, they provide a
  *       link to their source code repository. Proton then deploys and manages the infrastructure defined by the selected service template. For more
@@ -29,6 +34,8 @@ export interface CreateServiceTemplateCommandOutput extends CreateServiceTemplat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateServiceTemplateCommandInput - {@link CreateServiceTemplateCommandInput}
+ * @returns {@link CreateServiceTemplateCommandOutput}
  * @see {@link CreateServiceTemplateCommandInput} for command's `input` shape.
  * @see {@link CreateServiceTemplateCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -57,11 +64,20 @@ export interface CreateServiceTemplateCommandOutput extends CreateServiceTemplat
 export declare class CreateServiceTemplateCommand extends $Command<CreateServiceTemplateCommandInput, CreateServiceTemplateCommandOutput, ProtonClientResolvedConfig> {
     readonly input: CreateServiceTemplateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateServiceTemplateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceTemplateCommandInput, CreateServiceTemplateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateServiceTemplateVersionInput, CreateServiceTemplateVersionOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link CreateServiceTemplateVersionCommand}.
  */
 export interface CreateServiceTemplateVersionCommandInput extends CreateServiceTemplateVersionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateServiceTemplateVersionCommand}.
  */
 export interface CreateServiceTemplateVersionCommandOutput extends CreateServiceTemplateVersionOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface CreateServiceTemplateVersionCommandOutput extends CreateService
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateServiceTemplateVersionCommandInput - {@link CreateServiceTemplateVersionCommandInput}
+ * @returns {@link CreateServiceTemplateVersionCommandOutput}
  * @see {@link CreateServiceTemplateVersionCommandInput} for command's `input` shape.
  * @see {@link CreateServiceTemplateVersionCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -57,11 +64,20 @@ export interface CreateServiceTemplateVersionCommandOutput extends CreateService
 export declare class CreateServiceTemplateVersionCommand extends $Command<CreateServiceTemplateVersionCommandInput, CreateServiceTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
     readonly input: CreateServiceTemplateVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateServiceTemplateVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceTemplateVersionCommandInput, CreateServiceTemplateVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateTemplateSyncConfigInput, CreateTemplateSyncConfigOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link CreateTemplateSyncConfigCommand}.
  */
 export interface CreateTemplateSyncConfigCommandInput extends CreateTemplateSyncConfigInput {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTemplateSyncConfigCommand}.
  */
 export interface CreateTemplateSyncConfigCommandOutput extends CreateTemplateSyncConfigOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Set up a template to create new template versions automatically by tracking a linked repository. A linked
  *    repository is a repository that has been registered with Proton. For more information, see <a>CreateRepository</a>.</p>
  *          <p>When a commit is pushed to your linked repository, Proton checks for changes to your repository template
@@ -30,6 +35,8 @@ export interface CreateTemplateSyncConfigCommandOutput extends CreateTemplateSyn
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTemplateSyncConfigCommandInput - {@link CreateTemplateSyncConfigCommandInput}
+ * @returns {@link CreateTemplateSyncConfigCommandOutput}
  * @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.
@@ -58,11 +65,20 @@ export interface CreateTemplateSyncConfigCommandOutput extends CreateTemplateSyn
 export declare class CreateTemplateSyncConfigCommand extends $Command<CreateTemplateSyncConfigCommandInput, CreateTemplateSyncConfigCommandOutput, ProtonClientResolvedConfig> {
     readonly input: CreateTemplateSyncConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTemplateSyncConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTemplateSyncConfigCommandInput, CreateTemplateSyncConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteComponentInput, DeleteComponentOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteComponentCommand}.
  */
 export interface DeleteComponentCommandInput extends DeleteComponentInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteComponentCommand}.
  */
 export interface DeleteComponentCommandOutput extends DeleteComponentOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Delete an Proton component resource.</p>
  *          <p>For more information about components, see
  *   <a href="https://docs.aws.amazon.com/proton/latest/userguide/ag-components.html">Proton components</a> in the
@@ -28,6 +33,8 @@ export interface DeleteComponentCommandOutput extends DeleteComponentOutput, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteComponentCommandInput - {@link DeleteComponentCommandInput}
+ * @returns {@link DeleteComponentCommandOutput}
  * @see {@link DeleteComponentCommandInput} for command's `input` shape.
  * @see {@link DeleteComponentCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -55,11 +62,20 @@ export interface DeleteComponentCommandOutput extends DeleteComponentOutput, __M
 export declare class DeleteComponentCommand extends $Command<DeleteComponentCommandInput, DeleteComponentCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteComponentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteComponentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteComponentCommandInput, DeleteComponentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteEnvironmentAccountConnectionInput, DeleteEnvironmentAccountConnectionOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteEnvironmentAccountConnectionCommand}.
  */
 export interface DeleteEnvironmentAccountConnectionCommandInput extends DeleteEnvironmentAccountConnectionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEnvironmentAccountConnectionCommand}.
  */
 export interface DeleteEnvironmentAccountConnectionCommandOutput extends DeleteEnvironmentAccountConnectionOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <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 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
@@ -30,6 +35,8 @@ export interface DeleteEnvironmentAccountConnectionCommandOutput extends DeleteE
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEnvironmentAccountConnectionCommandInput - {@link DeleteEnvironmentAccountConnectionCommandInput}
+ * @returns {@link DeleteEnvironmentAccountConnectionCommandOutput}
  * @see {@link DeleteEnvironmentAccountConnectionCommandInput} for command's `input` shape.
  * @see {@link DeleteEnvironmentAccountConnectionCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -57,11 +64,20 @@ export interface DeleteEnvironmentAccountConnectionCommandOutput extends DeleteE
 export declare class DeleteEnvironmentAccountConnectionCommand extends $Command<DeleteEnvironmentAccountConnectionCommandInput, DeleteEnvironmentAccountConnectionCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteEnvironmentAccountConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEnvironmentAccountConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentAccountConnectionCommandInput, DeleteEnvironmentAccountConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteEnvironmentInput, DeleteEnvironmentOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteEnvironmentCommand}.
  */
 export interface DeleteEnvironmentCommandInput extends DeleteEnvironmentInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEnvironmentCommand}.
  */
 export interface DeleteEnvironmentCommandOutput extends DeleteEnvironmentOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Delete an environment.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteEnvironmentCommandOutput extends DeleteEnvironmentOutput,
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEnvironmentCommandInput - {@link DeleteEnvironmentCommandInput}
+ * @returns {@link DeleteEnvironmentCommandOutput}
  * @see {@link DeleteEnvironmentCommandInput} for command's `input` shape.
  * @see {@link DeleteEnvironmentCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteEnvironmentCommandOutput extends DeleteEnvironmentOutput,
 export declare class DeleteEnvironmentCommand extends $Command<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteEnvironmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEnvironmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteEnvironmentTemplateInput, DeleteEnvironmentTemplateOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteEnvironmentTemplateCommand}.
  */
 export interface DeleteEnvironmentTemplateCommandInput extends DeleteEnvironmentTemplateInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEnvironmentTemplateCommand}.
  */
 export interface DeleteEnvironmentTemplateCommandOutput extends DeleteEnvironmentTemplateOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>If no other major or minor versions of an environment template exist, delete the environment template.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteEnvironmentTemplateCommandOutput extends DeleteEnvironmen
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEnvironmentTemplateCommandInput - {@link DeleteEnvironmentTemplateCommandInput}
+ * @returns {@link DeleteEnvironmentTemplateCommandOutput}
  * @see {@link DeleteEnvironmentTemplateCommandInput} for command's `input` shape.
  * @see {@link DeleteEnvironmentTemplateCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteEnvironmentTemplateCommandOutput extends DeleteEnvironmen
 export declare class DeleteEnvironmentTemplateCommand extends $Command<DeleteEnvironmentTemplateCommandInput, DeleteEnvironmentTemplateCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteEnvironmentTemplateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEnvironmentTemplateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentTemplateCommandInput, DeleteEnvironmentTemplateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteEnvironmentTemplateVersionInput, DeleteEnvironmentTemplateVersionOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteEnvironmentTemplateVersionCommand}.
  */
 export interface DeleteEnvironmentTemplateVersionCommandInput extends DeleteEnvironmentTemplateVersionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEnvironmentTemplateVersionCommand}.
  */
 export interface DeleteEnvironmentTemplateVersionCommandOutput extends DeleteEnvironmentTemplateVersionOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <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 backward compatible.</p>
@@ -30,6 +35,8 @@ export interface DeleteEnvironmentTemplateVersionCommandOutput extends DeleteEnv
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEnvironmentTemplateVersionCommandInput - {@link DeleteEnvironmentTemplateVersionCommandInput}
+ * @returns {@link DeleteEnvironmentTemplateVersionCommandOutput}
  * @see {@link DeleteEnvironmentTemplateVersionCommandInput} for command's `input` shape.
  * @see {@link DeleteEnvironmentTemplateVersionCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -57,11 +64,20 @@ export interface DeleteEnvironmentTemplateVersionCommandOutput extends DeleteEnv
 export declare class DeleteEnvironmentTemplateVersionCommand extends $Command<DeleteEnvironmentTemplateVersionCommandInput, DeleteEnvironmentTemplateVersionCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteEnvironmentTemplateVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEnvironmentTemplateVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentTemplateVersionCommandInput, DeleteEnvironmentTemplateVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteRepositoryInput, DeleteRepositoryOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteRepositoryCommand}.
  */
 export interface DeleteRepositoryCommandInput extends DeleteRepositoryInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteRepositoryCommand}.
  */
 export interface DeleteRepositoryCommandOutput extends DeleteRepositoryOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>De-register and unlink your repository.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteRepositoryCommandOutput extends DeleteRepositoryOutput, _
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteRepositoryCommandInput - {@link DeleteRepositoryCommandInput}
+ * @returns {@link DeleteRepositoryCommandOutput}
  * @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.
@@ -52,11 +59,20 @@ export interface DeleteRepositoryCommandOutput extends DeleteRepositoryOutput, _
 export declare class DeleteRepositoryCommand extends $Command<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteRepositoryCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteRepositoryCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRepositoryCommandInput, DeleteRepositoryCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteServiceInput, DeleteServiceOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteServiceCommand}.
  */
 export interface DeleteServiceCommandInput extends DeleteServiceInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteServiceCommand}.
  */
 export interface DeleteServiceCommandOutput extends DeleteServiceOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Delete a service, with its instances and pipeline.</p>
  *          <note>
  *             <p>You can't delete a service if it has any service instances that have components attached to them.</p>
@@ -31,6 +36,8 @@ export interface DeleteServiceCommandOutput extends DeleteServiceOutput, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteServiceCommandInput - {@link DeleteServiceCommandInput}
+ * @returns {@link DeleteServiceCommandOutput}
  * @see {@link DeleteServiceCommandInput} for command's `input` shape.
  * @see {@link DeleteServiceCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -58,11 +65,20 @@ export interface DeleteServiceCommandOutput extends DeleteServiceOutput, __Metad
 export declare class DeleteServiceCommand extends $Command<DeleteServiceCommandInput, DeleteServiceCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteServiceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteServiceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceCommandInput, DeleteServiceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteServiceTemplateInput, DeleteServiceTemplateOutput } from "../models/models_0";
 import { ProtonClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ProtonClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteServiceTemplateCommand}.
  */
 export interface DeleteServiceTemplateCommandInput extends DeleteServiceTemplateInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteServiceTemplateCommand}.
  */
 export interface DeleteServiceTemplateCommandOutput extends DeleteServiceTemplateOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>If no other major or minor versions of the service template exist, delete the service template.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteServiceTemplateCommandOutput extends DeleteServiceTemplat
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteServiceTemplateCommandInput - {@link DeleteServiceTemplateCommandInput}
+ * @returns {@link DeleteServiceTemplateCommandOutput}
  * @see {@link DeleteServiceTemplateCommandInput} for command's `input` shape.
  * @see {@link DeleteServiceTemplateCommandOutput} for command's `response` shape.
  * @see {@link ProtonClientResolvedConfig | config} for ProtonClient's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteServiceTemplateCommandOutput extends DeleteServiceTemplat
 export declare class DeleteServiceTemplateCommand extends $Command<DeleteServiceTemplateCommandInput, DeleteServiceTemplateCommandOutput, ProtonClientResolvedConfig> {
     readonly input: DeleteServiceTemplateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteServiceTemplateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ProtonClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceTemplateCommandInput, DeleteServiceTemplateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }