@aws-sdk/client-service-catalog 3.35.0 → 3.38.0

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

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

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

@@ -6,30 +6,11 @@ export interface GetAWSOrganizationsAccessStatusCommandInput extends GetAWSOrgan
 }
 export interface GetAWSOrganizationsAccessStatusCommandOutput extends GetAWSOrganizationsAccessStatusOutput, __MetadataBearer {
 }
-/**
- * <p>Get the Access Status for AWS Organization portfolio share feature. This API can only be
- *          called by the management account in the organization or by a delegated admin.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, GetAWSOrganizationsAccessStatusCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, GetAWSOrganizationsAccessStatusCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new GetAWSOrganizationsAccessStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAWSOrganizationsAccessStatusCommandInput} for command's `input` shape.
- * @see {@link GetAWSOrganizationsAccessStatusCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAWSOrganizationsAccessStatusCommand extends $Command<GetAWSOrganizationsAccessStatusCommandInput, GetAWSOrganizationsAccessStatusCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: GetAWSOrganizationsAccessStatusCommandInput;
     constructor(input: GetAWSOrganizationsAccessStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAWSOrganizationsAccessStatusCommandInput, GetAWSOrganizationsAccessStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetProvisionedProductOutputsCommandInput extends GetProvisioned
 }
 export interface GetProvisionedProductOutputsCommandOutput extends GetProvisionedProductOutputsOutput, __MetadataBearer {
 }
-/**
- * <p>This API takes either a <code>ProvisonedProductId</code> or a <code>ProvisionedProductName</code>, along with a list of one or more output keys, and responds with the key/value pairs of those outputs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, GetProvisionedProductOutputsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, GetProvisionedProductOutputsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new GetProvisionedProductOutputsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetProvisionedProductOutputsCommandInput} for command's `input` shape.
- * @see {@link GetProvisionedProductOutputsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetProvisionedProductOutputsCommand extends $Command<GetProvisionedProductOutputsCommandInput, GetProvisionedProductOutputsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: GetProvisionedProductOutputsCommandInput;
     constructor(input: GetProvisionedProductOutputsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetProvisionedProductOutputsCommandInput, GetProvisionedProductOutputsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface ImportAsProvisionedProductCommandInput extends ImportAsProvisio
 }
 export interface ImportAsProvisionedProductCommandOutput extends ImportAsProvisionedProductOutput, __MetadataBearer {
 }
-/**
- * <p>Requests the import of a resource as a Service Catalog provisioned product that is
- *          associated to a Service Catalog product and provisioning artifact. Once imported, all
- *          supported Service Catalog governance actions are supported on the provisioned
- *          product.</p>
- *          <p>Resource import only supports CloudFormation stack ARNs. CloudFormation StackSets and
- *          non-root nested stacks are not supported.</p>
- *          <p>The CloudFormation stack must have one of the following statuses to be imported:
- *          <code>CREATE_COMPLETE</code>, <code>UPDATE_COMPLETE</code>, <code>UPDATE_ROLLBACK_COMPLETE</code>, <code>IMPORT_COMPLETE</code>,
- *          <code>IMPORT_ROLLBACK_COMPLETE</code>.</p>
- *          <p>Import of the resource requires that the CloudFormation stack template matches the
- *          associated Service Catalog product provisioning artifact. </p>
- *
- *          <p>The user or role that performs this operation must have the <code>cloudformation:GetTemplate</code>
- *          and <code>cloudformation:DescribeStacks</code> IAM policy permissions. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ImportAsProvisionedProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ImportAsProvisionedProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ImportAsProvisionedProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportAsProvisionedProductCommandInput} for command's `input` shape.
- * @see {@link ImportAsProvisionedProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportAsProvisionedProductCommand extends $Command<ImportAsProvisionedProductCommandInput, ImportAsProvisionedProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ImportAsProvisionedProductCommandInput;
     constructor(input: ImportAsProvisionedProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportAsProvisionedProductCommandInput, ImportAsProvisionedProductCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface ListLaunchPathsCommandInput extends ListLaunchPathsInput {
 }
 export interface ListLaunchPathsCommandOutput extends ListLaunchPathsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the paths to the specified product. A path is how the user
- *          has access to a specified product, and is necessary when provisioning a product. A path
- *          also determines the constraints put on the product.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListLaunchPathsCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListLaunchPathsCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListLaunchPathsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListLaunchPathsCommandInput} for command's `input` shape.
- * @see {@link ListLaunchPathsCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListLaunchPathsCommand extends $Command<ListLaunchPathsCommandInput, ListLaunchPathsCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListLaunchPathsCommandInput;
     constructor(input: ListLaunchPathsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLaunchPathsCommandInput, ListLaunchPathsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListOrganizationPortfolioAccessCommandInput extends ListOrganiz
 }
 export interface ListOrganizationPortfolioAccessCommandOutput extends ListOrganizationPortfolioAccessOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the organization nodes that have access to the specified portfolio. This API can
- *          only be called by the management account in the organization or by a delegated
- *          admin.</p>
- *          <p>If a delegated admin is de-registered, they can no longer perform this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListOrganizationPortfolioAccessCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListOrganizationPortfolioAccessCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListOrganizationPortfolioAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListOrganizationPortfolioAccessCommandInput} for command's `input` shape.
- * @see {@link ListOrganizationPortfolioAccessCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListOrganizationPortfolioAccessCommand extends $Command<ListOrganizationPortfolioAccessCommandInput, ListOrganizationPortfolioAccessCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListOrganizationPortfolioAccessCommandInput;
     constructor(input: ListOrganizationPortfolioAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOrganizationPortfolioAccessCommandInput, ListOrganizationPortfolioAccessCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListPortfolioAccessCommandInput extends ListPortfolioAccessInpu
 }
 export interface ListPortfolioAccessCommandOutput extends ListPortfolioAccessOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the account IDs that have access to the specified portfolio.</p>
- *          <p>A delegated admin can list the accounts that have access to the shared portfolio. Note that if a delegated admin is de-registered, they can no longer perform this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, ListPortfolioAccessCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, ListPortfolioAccessCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new ListPortfolioAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPortfolioAccessCommandInput} for command's `input` shape.
- * @see {@link ListPortfolioAccessCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPortfolioAccessCommand extends $Command<ListPortfolioAccessCommandInput, ListPortfolioAccessCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: ListPortfolioAccessCommandInput;
     constructor(input: ListPortfolioAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPortfolioAccessCommandInput, ListPortfolioAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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