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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,36 +6,11 @@ export interface DescribeProvisioningParametersCommandInput extends DescribeProv
 }
 export interface DescribeProvisioningParametersCommandOutput extends DescribeProvisioningParametersOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about the configuration required to provision the specified product using
- *          the specified provisioning artifact.</p>
- *          <p>If the output contains a TagOption key with an empty list of values, there is a
- *          TagOption conflict for that key. The end user cannot take action to fix the conflict, and
- *          launch is not blocked. In subsequent calls to <a>ProvisionProduct</a>,
- *          do not include conflicted TagOption keys as tags, or this causes the error
- *          "Parameter validation failed: Missing required parameter in Tags[<i>N</i>]:<i>Value</i>".
- *          Tag the provisioned product with the value <code>sc-tagoption-conflict-portfolioId-productId</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, DescribeProvisioningParametersCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DescribeProvisioningParametersCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DescribeProvisioningParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeProvisioningParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeProvisioningParametersCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeProvisioningParametersCommand extends $Command<DescribeProvisioningParametersCommandInput, DescribeProvisioningParametersCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DescribeProvisioningParametersCommandInput;
     constructor(input: DescribeProvisioningParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProvisioningParametersCommandInput, DescribeProvisioningParametersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DescribeRecordCommandInput extends DescribeRecordInput {
 }
 export interface DescribeRecordCommandOutput extends DescribeRecordOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about the specified request operation.</p>
- *          <p>Use this operation after calling a request operation (for example, <a>ProvisionProduct</a>,
- *          <a>TerminateProvisionedProduct</a>, or <a>UpdateProvisionedProduct</a>).
- *       </p>
- *          <note>
- *             <p>If a provisioned product was transferred to a new owner using <a>UpdateProvisionedProductProperties</a>, the new owner
- *       will be able to describe all past records for that product. The previous owner will no longer be able to describe the records, but will be able to
- *       use <a>ListRecordHistory</a> to see the product's history from when he was the owner.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, DescribeRecordCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DescribeRecordCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DescribeRecordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRecordCommandInput} for command's `input` shape.
- * @see {@link DescribeRecordCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRecordCommand extends $Command<DescribeRecordCommandInput, DescribeRecordCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DescribeRecordCommandInput;
     constructor(input: DescribeRecordCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRecordCommandInput, DescribeRecordCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface DisableAWSOrganizationsAccessCommandInput extends DisableAWSOrg
 }
 export interface DisableAWSOrganizationsAccessCommandOutput extends DisableAWSOrganizationsAccessOutput, __MetadataBearer {
 }
-/**
- * <p>Disable portfolio sharing through AWS Organizations feature. This feature will not
- *          delete your current shares but it will prevent you from creating new shares throughout your
- *          organization. Current shares will not be in sync with your organization structure if it
- *          changes after calling this API. This API can only be called by the management  account in
- *          the organization.</p>
- *          <p>This API can't be invoked if there are active delegated administrators in the organization.</p>
- *          <p>Note that a delegated administrator is not authorized to invoke <code>DisableAWSOrganizationsAccess</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, DisableAWSOrganizationsAccessCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DisableAWSOrganizationsAccessCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DisableAWSOrganizationsAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableAWSOrganizationsAccessCommandInput} for command's `input` shape.
- * @see {@link DisableAWSOrganizationsAccessCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableAWSOrganizationsAccessCommand extends $Command<DisableAWSOrganizationsAccessCommandInput, DisableAWSOrganizationsAccessCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DisableAWSOrganizationsAccessCommandInput;
     constructor(input: DisableAWSOrganizationsAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableAWSOrganizationsAccessCommandInput, DisableAWSOrganizationsAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

@@ -6,34 +6,11 @@ export interface EnableAWSOrganizationsAccessCommandInput extends EnableAWSOrgan
 }
 export interface EnableAWSOrganizationsAccessCommandOutput extends EnableAWSOrganizationsAccessOutput, __MetadataBearer {
 }
-/**
- * <p>Enable portfolio sharing feature through AWS Organizations. This API will allow Service
- *          Catalog to receive updates on your organization in order to sync your shares with the
- *          current structure. This API can only be called by the management  account in the
- *          organization.</p>
- *          <p>By calling this API Service Catalog will make a call to organizations:EnableAWSServiceAccess on your behalf so that your shares can be in sync with any changes in your AWS Organizations structure.</p>
- *          <p>Note that a delegated administrator is not authorized to invoke <code>EnableAWSOrganizationsAccess</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, EnableAWSOrganizationsAccessCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, EnableAWSOrganizationsAccessCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new EnableAWSOrganizationsAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableAWSOrganizationsAccessCommandInput} for command's `input` shape.
- * @see {@link EnableAWSOrganizationsAccessCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableAWSOrganizationsAccessCommand extends $Command<EnableAWSOrganizationsAccessCommandInput, EnableAWSOrganizationsAccessCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: EnableAWSOrganizationsAccessCommandInput;
     constructor(input: EnableAWSOrganizationsAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableAWSOrganizationsAccessCommandInput, EnableAWSOrganizationsAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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