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

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

@@ -6,35 +6,11 @@ export interface CreateProvisionedProductPlanCommandInput extends CreateProvisio
 }
 export interface CreateProvisionedProductPlanCommandOutput extends CreateProvisionedProductPlanOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a plan. A plan includes the list of resources to be
- *          created (when provisioning a new product) or modified (when updating a provisioned product)
- *          when the plan is executed.</p>
- *          <p>You can create one plan per provisioned product. To create a plan for an existing
- *          provisioned product, the product status must be AVAILBLE or TAINTED.</p>
- *          <p>To view the resource changes in the change set, use <a>DescribeProvisionedProductPlan</a>.
- *          To create or modify the provisioned product, use <a>ExecuteProvisionedProductPlan</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, CreateProvisionedProductPlanCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, CreateProvisionedProductPlanCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new CreateProvisionedProductPlanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProvisionedProductPlanCommandInput} for command's `input` shape.
- * @see {@link CreateProvisionedProductPlanCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProvisionedProductPlanCommand extends $Command<CreateProvisionedProductPlanCommandInput, CreateProvisionedProductPlanCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: CreateProvisionedProductPlanCommandInput;
     constructor(input: CreateProvisionedProductPlanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProvisionedProductPlanCommandInput, CreateProvisionedProductPlanCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateProvisioningArtifactCommandInput extends CreateProvisioni
 }
 export interface CreateProvisioningArtifactCommandOutput extends CreateProvisioningArtifactOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a provisioning artifact (also known as a version) for the specified product.</p>
- *          <p>You cannot create a provisioning artifact for a product that was shared with you.</p>
- *
- *          <p>The user or role that performs this operation must have the <code>cloudformation:GetTemplate</code>
- *          IAM policy permission. This policy permission is required when using the
- *          <code>ImportFromPhysicalId</code> template source in the information data section.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, CreateProvisioningArtifactCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, CreateProvisioningArtifactCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new CreateProvisioningArtifactCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProvisioningArtifactCommandInput} for command's `input` shape.
- * @see {@link CreateProvisioningArtifactCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProvisioningArtifactCommand extends $Command<CreateProvisioningArtifactCommandInput, CreateProvisioningArtifactCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: CreateProvisioningArtifactCommandInput;
     constructor(input: CreateProvisioningArtifactCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProvisioningArtifactCommandInput, CreateProvisioningArtifactCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DeleteConstraintCommandInput extends DeleteConstraintInput {
 }
 export interface DeleteConstraintCommandOutput extends DeleteConstraintOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified constraint.</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, DeleteConstraintCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DeleteConstraintCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DeleteConstraintCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteConstraintCommandInput} for command's `input` shape.
- * @see {@link DeleteConstraintCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteConstraintCommand extends $Command<DeleteConstraintCommandInput, DeleteConstraintCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DeleteConstraintCommandInput;
     constructor(input: DeleteConstraintCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConstraintCommandInput, DeleteConstraintCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeletePortfolioCommandInput extends DeletePortfolioInput {
 }
 export interface DeletePortfolioCommandOutput extends DeletePortfolioOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified portfolio.</p>
- *          <p>You cannot delete a portfolio if it was shared with you or if it has associated
- *          products, users, constraints, or shared accounts.</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, DeletePortfolioCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DeletePortfolioCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DeletePortfolioCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePortfolioCommandInput} for command's `input` shape.
- * @see {@link DeletePortfolioCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePortfolioCommand extends $Command<DeletePortfolioCommandInput, DeletePortfolioCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DeletePortfolioCommandInput;
     constructor(input: DeletePortfolioCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePortfolioCommandInput, DeletePortfolioCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeletePortfolioShareCommandInput extends DeletePortfolioShareIn
 }
 export interface DeletePortfolioShareCommandOutput extends DeletePortfolioShareOutput, __MetadataBearer {
 }
-/**
- * <p>Stops sharing the specified portfolio with the specified account or organization
- *          node. Shares to an organization node can only be deleted by the management account of an
- *          organization or by a delegated administrator.</p>
- *          <p>Note that if a delegated admin is de-registered, portfolio shares created from that account are removed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, DeletePortfolioShareCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DeletePortfolioShareCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DeletePortfolioShareCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePortfolioShareCommandInput} for command's `input` shape.
- * @see {@link DeletePortfolioShareCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePortfolioShareCommand extends $Command<DeletePortfolioShareCommandInput, DeletePortfolioShareCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DeletePortfolioShareCommandInput;
     constructor(input: DeletePortfolioShareCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePortfolioShareCommandInput, DeletePortfolioShareCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteProductCommandInput extends DeleteProductInput {
 }
 export interface DeleteProductCommandOutput extends DeleteProductOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified product.</p>
- *          <p>You cannot delete a product if it was shared with you or is associated with a 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, DeleteProductCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DeleteProductCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DeleteProductCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteProductCommandInput} for command's `input` shape.
- * @see {@link DeleteProductCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteProductCommand extends $Command<DeleteProductCommandInput, DeleteProductCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DeleteProductCommandInput;
     constructor(input: DeleteProductCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProductCommandInput, DeleteProductCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DescribePortfolioCommandInput extends DescribePortfolioInput {
 }
 export interface DescribePortfolioCommandOutput extends DescribePortfolioOutput, __MetadataBearer {
 }
-/**
- * <p>Gets information about 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, DescribePortfolioCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DescribePortfolioCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DescribePortfolioCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePortfolioCommandInput} for command's `input` shape.
- * @see {@link DescribePortfolioCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePortfolioCommand extends $Command<DescribePortfolioCommandInput, DescribePortfolioCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DescribePortfolioCommandInput;
     constructor(input: DescribePortfolioCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePortfolioCommandInput, DescribePortfolioCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribePortfolioShareStatusCommandInput extends DescribePortfo
 }
 export interface DescribePortfolioShareStatusCommandOutput extends DescribePortfolioShareStatusOutput, __MetadataBearer {
 }
-/**
- * <p>Gets the status of the specified portfolio share operation. 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, DescribePortfolioShareStatusCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DescribePortfolioShareStatusCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DescribePortfolioShareStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePortfolioShareStatusCommandInput} for command's `input` shape.
- * @see {@link DescribePortfolioShareStatusCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePortfolioShareStatusCommand extends $Command<DescribePortfolioShareStatusCommandInput, DescribePortfolioShareStatusCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DescribePortfolioShareStatusCommandInput;
     constructor(input: DescribePortfolioShareStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePortfolioShareStatusCommandInput, DescribePortfolioShareStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribePortfolioSharesCommandInput extends DescribePortfolioSh
 }
 export interface DescribePortfolioSharesCommandOutput extends DescribePortfolioSharesOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a summary of each of the portfolio shares that were created for the specified portfolio.</p>
- *          <p>You can use this API to determine which accounts or organizational nodes this
- *          portfolio have been shared, whether the recipient entity has imported the share, and
- *          whether TagOptions are included with the share.</p>
- *          <p>The <code>PortfolioId</code> and <code>Type</code> parameters are both required.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ServiceCatalogClient, DescribePortfolioSharesCommand } from "@aws-sdk/client-service-catalog"; // ES Modules import
- * // const { ServiceCatalogClient, DescribePortfolioSharesCommand } = require("@aws-sdk/client-service-catalog"); // CommonJS import
- * const client = new ServiceCatalogClient(config);
- * const command = new DescribePortfolioSharesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePortfolioSharesCommandInput} for command's `input` shape.
- * @see {@link DescribePortfolioSharesCommandOutput} for command's `response` shape.
- * @see {@link ServiceCatalogClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePortfolioSharesCommand extends $Command<DescribePortfolioSharesCommandInput, DescribePortfolioSharesCommandOutput, ServiceCatalogClientResolvedConfig> {
     readonly input: DescribePortfolioSharesCommandInput;
     constructor(input: DescribePortfolioSharesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ServiceCatalogClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePortfolioSharesCommandInput, DescribePortfolioSharesCommandOutput>;
     private serialize;
     private deserialize;

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

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