@aws-sdk/client-service-catalog 3.36.0 → 3.36.1

package/dist-types/ts3.4/commands/ListServiceActionsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListServiceActionsCommandInput extends ListServiceActionsInput
 }
 export interface ListServiceActionsCommandOutput extends ListServiceActionsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists all self-service actions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListServiceActionsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListServiceActionsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListServiceActionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServiceActionsCommandInput} for command's `input` shape.
- * @see {@link ListServiceActionsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListServiceActionsCommand extends $Command<ListServiceActionsCommandInput, ListServiceActionsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListServiceActionsCommandInput;
     constructor(input: ListServiceActionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServiceActionsCommandInput, ListServiceActionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListServiceActionsForProvisioningArtifactCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListServiceActionsForProvisioningArtifactCommandInput extends L
 }
 export interface ListServiceActionsForProvisioningArtifactCommandOutput extends ListServiceActionsForProvisioningArtifactOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a paginated list of self-service actions associated with the specified Product ID and Provisioning Artifact ID.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListServiceActionsForProvisioningArtifactCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListServiceActionsForProvisioningArtifactCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListServiceActionsForProvisioningArtifactCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServiceActionsForProvisioningArtifactCommandInput} for command's `input` shape.
- * @see {@link ListServiceActionsForProvisioningArtifactCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListServiceActionsForProvisioningArtifactCommand extends $Command<ListServiceActionsForProvisioningArtifactCommandInput, ListServiceActionsForProvisioningArtifactCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListServiceActionsForProvisioningArtifactCommandInput;
     constructor(input: ListServiceActionsForProvisioningArtifactCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServiceActionsForProvisioningArtifactCommandInput, ListServiceActionsForProvisioningArtifactCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListStackInstancesForProvisionedProductCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListStackInstancesForProvisionedProductCommandInput extends Lis
 }
 export interface ListStackInstancesForProvisionedProductCommandOutput extends ListStackInstancesForProvisionedProductOutput, __MetadataBearer {
 }
-/**
- * <p>Returns summary information about stack instances that are associated with the specified <code>CFN_STACKSET</code> type provisioned product. You can filter for stack instances that are associated with a specific AWS account name or region. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListStackInstancesForProvisionedProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListStackInstancesForProvisionedProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListStackInstancesForProvisionedProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStackInstancesForProvisionedProductCommandInput} for command's `input` shape.
- * @see {@link ListStackInstancesForProvisionedProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListStackInstancesForProvisionedProductCommand extends $Command<ListStackInstancesForProvisionedProductCommandInput, ListStackInstancesForProvisionedProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListStackInstancesForProvisionedProductCommandInput;
     constructor(input: ListStackInstancesForProvisionedProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStackInstancesForProvisionedProductCommandInput, ListStackInstancesForProvisionedProductCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTagOptionsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListTagOptionsCommandInput extends ListTagOptionsInput {
 }
 export interface ListTagOptionsCommandOutput extends ListTagOptionsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the specified TagOptions or all TagOptions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListTagOptionsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListTagOptionsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListTagOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagOptionsCommandInput} for command's `input` shape.
- * @see {@link ListTagOptionsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagOptionsCommand extends $Command<ListTagOptionsCommandInput, ListTagOptionsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListTagOptionsCommandInput;
     constructor(input: ListTagOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagOptionsCommandInput, ListTagOptionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ProvisionProductCommand.d.ts

@@ -6,37 +6,11 @@ export interface ProvisionProductCommandInput extends ProvisionProductInput {
 }
 export interface ProvisionProductCommandOutput extends ProvisionProductOutput, __MetadataBearer {
 }
-/**
- * <p>Provisions the specified product.</p>
- *          <p>A provisioned product is a resourced instance of a product.
- *          For example, provisioning a product based on a CloudFormation template launches a
- *          CloudFormation stack and its underlying resources.
- *          You can check the status of this request using <a>DescribeRecord</a>.</p>
- *          <p>If the request contains a tag key with an empty list of values, there is a
- *          tag conflict for that key. Do not include conflicted keys as tags, or this causes
- *          the error "Parameter validation failed: Missing required parameter in
- *          Tags[<i>N</i>]:<i>Value</i>".</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ProvisionProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ProvisionProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ProvisionProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ProvisionProductCommandInput} for command's `input` shape.
- * @see {@link ProvisionProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ProvisionProductCommand extends $Command<ProvisionProductCommandInput, ProvisionProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ProvisionProductCommandInput;
     constructor(input: ProvisionProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ProvisionProductCommandInput, ProvisionProductCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RejectPortfolioShareCommand.d.ts

@@ -6,29 +6,11 @@ export interface RejectPortfolioShareCommandInput extends RejectPortfolioShareIn
 }
 export interface RejectPortfolioShareCommandOutput extends RejectPortfolioShareOutput, __MetadataBearer {
 }
-/**
- * <p>Rejects an offer to share the specified portfolio.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, RejectPortfolioShareCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, RejectPortfolioShareCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new RejectPortfolioShareCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RejectPortfolioShareCommandInput} for command's `input` shape.
- * @see {@link RejectPortfolioShareCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RejectPortfolioShareCommand extends $Command<RejectPortfolioShareCommandInput, RejectPortfolioShareCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: RejectPortfolioShareCommandInput;
     constructor(input: RejectPortfolioShareCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectPortfolioShareCommandInput, RejectPortfolioShareCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ScanProvisionedProductsCommand.d.ts

@@ -6,30 +6,11 @@ export interface ScanProvisionedProductsCommandInput extends ScanProvisionedProd
 }
 export interface ScanProvisionedProductsCommandOutput extends ScanProvisionedProductsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the provisioned products that are available (not terminated).</p>
- *          <p>To use additional filtering, see <a>SearchProvisionedProducts</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ScanProvisionedProductsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ScanProvisionedProductsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ScanProvisionedProductsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ScanProvisionedProductsCommandInput} for command's `input` shape.
- * @see {@link ScanProvisionedProductsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ScanProvisionedProductsCommand extends $Command<ScanProvisionedProductsCommandInput, ScanProvisionedProductsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ScanProvisionedProductsCommandInput;
     constructor(input: ScanProvisionedProductsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ScanProvisionedProductsCommandInput, ScanProvisionedProductsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SearchProductsAsAdminCommand.d.ts

@@ -6,29 +6,11 @@ export interface SearchProductsAsAdminCommandInput extends SearchProductsAsAdmin
 }
 export interface SearchProductsAsAdminCommandOutput extends SearchProductsAsAdminOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about the products for the specified portfolio or all products.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, SearchProductsAsAdminCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, SearchProductsAsAdminCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new SearchProductsAsAdminCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchProductsAsAdminCommandInput} for command's `input` shape.
- * @see {@link SearchProductsAsAdminCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchProductsAsAdminCommand extends $Command<SearchProductsAsAdminCommandInput, SearchProductsAsAdminCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: SearchProductsAsAdminCommandInput;
     constructor(input: SearchProductsAsAdminCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchProductsAsAdminCommandInput, SearchProductsAsAdminCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SearchProductsCommand.d.ts

@@ -6,29 +6,11 @@ export interface SearchProductsCommandInput extends SearchProductsInput {
 }
 export interface SearchProductsCommandOutput extends SearchProductsOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about the products to which the caller has access.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, SearchProductsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, SearchProductsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new SearchProductsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchProductsCommandInput} for command's `input` shape.
- * @see {@link SearchProductsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchProductsCommand extends $Command<SearchProductsCommandInput, SearchProductsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: SearchProductsCommandInput;
     constructor(input: SearchProductsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchProductsCommandInput, SearchProductsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SearchProvisionedProductsCommand.d.ts

@@ -6,29 +6,11 @@ export interface SearchProvisionedProductsCommandInput extends SearchProvisioned
 }
 export interface SearchProvisionedProductsCommandOutput extends SearchProvisionedProductsOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about the provisioned products that meet the specified criteria.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, SearchProvisionedProductsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, SearchProvisionedProductsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new SearchProvisionedProductsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchProvisionedProductsCommandInput} for command's `input` shape.
- * @see {@link SearchProvisionedProductsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchProvisionedProductsCommand extends $Command<SearchProvisionedProductsCommandInput, SearchProvisionedProductsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: SearchProvisionedProductsCommandInput;
     constructor(input: SearchProvisionedProductsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchProvisionedProductsCommandInput, SearchProvisionedProductsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TerminateProvisionedProductCommand.d.ts

@@ -6,31 +6,11 @@ export interface TerminateProvisionedProductCommandInput extends TerminateProvis
 }
 export interface TerminateProvisionedProductCommandOutput extends TerminateProvisionedProductOutput, __MetadataBearer {
 }
-/**
- * <p>Terminates the specified provisioned product.</p>
- *          <p>This operation does not delete any records associated with the provisioned product.</p>
- *          <p>You can check the status of this request using <a>DescribeRecord</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, TerminateProvisionedProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, TerminateProvisionedProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new TerminateProvisionedProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateProvisionedProductCommandInput} for command's `input` shape.
- * @see {@link TerminateProvisionedProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TerminateProvisionedProductCommand extends $Command<TerminateProvisionedProductCommandInput, TerminateProvisionedProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: TerminateProvisionedProductCommandInput;
     constructor(input: TerminateProvisionedProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateProvisionedProductCommandInput, TerminateProvisionedProductCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateConstraintCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateConstraintCommandInput extends UpdateConstraintInput {
 }
 export interface UpdateConstraintCommandOutput extends UpdateConstraintOutput, __MetadataBearer {
 }
-/**
- * <p>Updates the specified constraint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdateConstraintCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdateConstraintCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdateConstraintCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConstraintCommandInput} for command's `input` shape.
- * @see {@link UpdateConstraintCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConstraintCommand extends $Command<UpdateConstraintCommandInput, UpdateConstraintCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdateConstraintCommandInput;
     constructor(input: UpdateConstraintCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConstraintCommandInput, UpdateConstraintCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdatePortfolioCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdatePortfolioCommandInput extends UpdatePortfolioInput {
 }
 export interface UpdatePortfolioCommandOutput extends UpdatePortfolioOutput, __MetadataBearer {
 }
-/**
- * <p>Updates the specified portfolio.</p>
- *          <p>You cannot update a product that was shared with you.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdatePortfolioCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdatePortfolioCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdatePortfolioCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePortfolioCommandInput} for command's `input` shape.
- * @see {@link UpdatePortfolioCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdatePortfolioCommand extends $Command<UpdatePortfolioCommandInput, UpdatePortfolioCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdatePortfolioCommandInput;
     constructor(input: UpdatePortfolioCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePortfolioCommandInput, UpdatePortfolioCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdatePortfolioShareCommand.d.ts

@@ -6,37 +6,11 @@ export interface UpdatePortfolioShareCommandInput extends UpdatePortfolioShareIn
 }
 export interface UpdatePortfolioShareCommandOutput extends UpdatePortfolioShareOutput, __MetadataBearer {
 }
-/**
- * <p>Updates the specified portfolio share. You can use this API to enable or disable TagOptions sharing for an existing portfolio share. </p>
- *
- *          <p>The portfolio share cannot be updated if the <code> CreatePortfolioShare</code> operation is <code>IN_PROGRESS</code>, as the share is not available to recipient entities. In this case, you must wait for the portfolio share to be COMPLETED.</p>
- *
- *          <p>You must provide the <code>accountId</code> or organization node in the input, but not both.</p>
- *
- *          <p>If the portfolio is shared to both an external account and an organization node, and both shares need to be updated, you must invoke <code>UpdatePortfolioShare</code> separately for each share type. </p>
- *
- *          <p>This API cannot be used for removing the portfolio share. You must use <code>DeletePortfolioShare</code> API for that action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdatePortfolioShareCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdatePortfolioShareCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdatePortfolioShareCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePortfolioShareCommandInput} for command's `input` shape.
- * @see {@link UpdatePortfolioShareCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdatePortfolioShareCommand extends $Command<UpdatePortfolioShareCommandInput, UpdatePortfolioShareCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdatePortfolioShareCommandInput;
     constructor(input: UpdatePortfolioShareCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePortfolioShareCommandInput, UpdatePortfolioShareCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateProductCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateProductCommandInput extends UpdateProductInput {
 }
 export interface UpdateProductCommandOutput extends UpdateProductOutput, __MetadataBearer {
 }
-/**
- * <p>Updates the specified product.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdateProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdateProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdateProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateProductCommandInput} for command's `input` shape.
- * @see {@link UpdateProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateProductCommand extends $Command<UpdateProductCommandInput, UpdateProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdateProductCommandInput;
     constructor(input: UpdateProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProductCommandInput, UpdateProductCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateProvisionedProductCommand.d.ts

@@ -6,33 +6,11 @@ export interface UpdateProvisionedProductCommandInput extends UpdateProvisionedP
 }
 export interface UpdateProvisionedProductCommandOutput extends UpdateProvisionedProductOutput, __MetadataBearer {
 }
-/**
- * <p>Requests updates to the configuration of the specified provisioned product.</p>
- *          <p>If there are tags associated with the object, they cannot be updated or added.
- *          Depending on the specific updates requested, this operation can update with no
- *          interruption, with some interruption, or replace the provisioned product entirely.</p>
- *          <p>You can check the status of this request using <a>DescribeRecord</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdateProvisionedProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdateProvisionedProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdateProvisionedProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateProvisionedProductCommandInput} for command's `input` shape.
- * @see {@link UpdateProvisionedProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateProvisionedProductCommand extends $Command<UpdateProvisionedProductCommandInput, UpdateProvisionedProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdateProvisionedProductCommandInput;
     constructor(input: UpdateProvisionedProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProvisionedProductCommandInput, UpdateProvisionedProductCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateProvisionedProductPropertiesCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateProvisionedProductPropertiesCommandInput extends UpdatePr
 }
 export interface UpdateProvisionedProductPropertiesCommandOutput extends UpdateProvisionedProductPropertiesOutput, __MetadataBearer {
 }
-/**
- * <p>Requests updates to the properties of the specified provisioned product.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdateProvisionedProductPropertiesCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdateProvisionedProductPropertiesCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdateProvisionedProductPropertiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateProvisionedProductPropertiesCommandInput} for command's `input` shape.
- * @see {@link UpdateProvisionedProductPropertiesCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateProvisionedProductPropertiesCommand extends $Command<UpdateProvisionedProductPropertiesCommandInput, UpdateProvisionedProductPropertiesCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdateProvisionedProductPropertiesCommandInput;
     constructor(input: UpdateProvisionedProductPropertiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProvisionedProductPropertiesCommandInput, UpdateProvisionedProductPropertiesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateProvisioningArtifactCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateProvisioningArtifactCommandInput extends UpdateProvisioni
 }
 export interface UpdateProvisioningArtifactCommandOutput extends UpdateProvisioningArtifactOutput, __MetadataBearer {
 }
-/**
- * <p>Updates the specified provisioning artifact (also known as a version) for the specified product.</p>
- *          <p>You cannot update a provisioning artifact for a product that was shared with you.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, UpdateProvisioningArtifactCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, UpdateProvisioningArtifactCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new UpdateProvisioningArtifactCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateProvisioningArtifactCommandInput} for command's `input` shape.
- * @see {@link UpdateProvisioningArtifactCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateProvisioningArtifactCommand extends $Command<UpdateProvisioningArtifactCommandInput, UpdateProvisioningArtifactCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: UpdateProvisioningArtifactCommandInput;
     constructor(input: UpdateProvisioningArtifactCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateProvisioningArtifactCommandInput, UpdateProvisioningArtifactCommandOutput>;
     private serialize;
     private deserialize;