@aws-sdk/client-imagebuilder 3.35.0 → 3.38.0

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetImagePipelineCommandInput extends GetImagePipelineRequest {
 }
 export interface GetImagePipelineCommandOutput extends GetImagePipelineResponse, __MetadataBearer {
 }
-/**
- * <p> Gets an image pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, GetImagePipelineCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, GetImagePipelineCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new GetImagePipelineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetImagePipelineCommandInput} for command's `input` shape.
- * @see {@link GetImagePipelineCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetImagePipelineCommand extends $Command<GetImagePipelineCommandInput, GetImagePipelineCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: GetImagePipelineCommandInput;
     constructor(input: GetImagePipelineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImagePipelineCommandInput, GetImagePipelineCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetImagePolicyCommandInput extends GetImagePolicyRequest {
 }
 export interface GetImagePolicyCommandOutput extends GetImagePolicyResponse, __MetadataBearer {
 }
-/**
- * <p> Gets an image policy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, GetImagePolicyCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, GetImagePolicyCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new GetImagePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetImagePolicyCommandInput} for command's `input` shape.
- * @see {@link GetImagePolicyCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetImagePolicyCommand extends $Command<GetImagePolicyCommandInput, GetImagePolicyCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: GetImagePolicyCommandInput;
     constructor(input: GetImagePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImagePolicyCommandInput, GetImagePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetImageRecipeCommandInput extends GetImageRecipeRequest {
 }
 export interface GetImageRecipeCommandOutput extends GetImageRecipeResponse, __MetadataBearer {
 }
-/**
- * <p> Gets an image recipe.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, GetImageRecipeCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, GetImageRecipeCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new GetImageRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetImageRecipeCommandInput} for command's `input` shape.
- * @see {@link GetImageRecipeCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetImageRecipeCommand extends $Command<GetImageRecipeCommandInput, GetImageRecipeCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: GetImageRecipeCommandInput;
     constructor(input: GetImageRecipeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImageRecipeCommandInput, GetImageRecipeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetImageRecipePolicyCommandInput extends GetImageRecipePolicyRe
 }
 export interface GetImageRecipePolicyCommandOutput extends GetImageRecipePolicyResponse, __MetadataBearer {
 }
-/**
- * <p> Gets an image recipe policy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, GetImageRecipePolicyCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, GetImageRecipePolicyCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new GetImageRecipePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetImageRecipePolicyCommandInput} for command's `input` shape.
- * @see {@link GetImageRecipePolicyCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetImageRecipePolicyCommand extends $Command<GetImageRecipePolicyCommandInput, GetImageRecipePolicyCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: GetImageRecipePolicyCommandInput;
     constructor(input: GetImageRecipePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImageRecipePolicyCommandInput, GetImageRecipePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface ImportComponentCommandInput extends ImportComponentRequest {
 }
 export interface ImportComponentCommandOutput extends ImportComponentResponse, __MetadataBearer {
 }
-/**
- * <p>Imports a component and transforms its data into a component document.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ImportComponentCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ImportComponentCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ImportComponentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportComponentCommandInput} for command's `input` shape.
- * @see {@link ImportComponentCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportComponentCommand extends $Command<ImportComponentCommandInput, ImportComponentCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ImportComponentCommandInput;
     constructor(input: ImportComponentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportComponentCommandInput, ImportComponentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface ListComponentBuildVersionsCommandInput extends ListComponentBui
 }
 export interface ListComponentBuildVersionsCommandOutput extends ListComponentBuildVersionsResponse, __MetadataBearer {
 }
-/**
- * <p> Returns the list of component build versions for the specified semantic version.</p>
- * 		       <note>
- * 			         <p>The semantic version has four nodes: <major>.<minor>.<patch>/<build>.
- * 	You can assign values for the first three, and can filter on all of them.</p>
- * 			         <p>
- *                <b>Filtering:</b> With semantic versioning, you have the flexibility to use wildcards (x)
- * 	to specify the most recent versions or nodes when selecting the base image or components for your
- * 	recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be
- * 	wildcards.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListComponentBuildVersionsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListComponentBuildVersionsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListComponentBuildVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListComponentBuildVersionsCommandInput} for command's `input` shape.
- * @see {@link ListComponentBuildVersionsCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListComponentBuildVersionsCommand extends $Command<ListComponentBuildVersionsCommandInput, ListComponentBuildVersionsCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListComponentBuildVersionsCommandInput;
     constructor(input: ListComponentBuildVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListComponentBuildVersionsCommandInput, ListComponentBuildVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface ListComponentsCommandInput extends ListComponentsRequest {
 }
 export interface ListComponentsCommandOutput extends ListComponentsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the list of component build versions for the specified semantic version.</p>
- * 		       <note>
- * 			         <p>The semantic version has four nodes: <major>.<minor>.<patch>/<build>.
- * 	You can assign values for the first three, and can filter on all of them.</p>
- * 			         <p>
- *                <b>Filtering:</b> With semantic versioning, you have the flexibility to use wildcards (x)
- * 	to specify the most recent versions or nodes when selecting the base image or components for your
- * 	recipe. When you use a wildcard in any node, all nodes to the right of the first wildcard must also be
- * 	wildcards.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListComponentsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListComponentsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListComponentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListComponentsCommandInput} for command's `input` shape.
- * @see {@link ListComponentsCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListComponentsCommand extends $Command<ListComponentsCommandInput, ListComponentsCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListComponentsCommandInput;
     constructor(input: ListComponentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListComponentsCommandInput, ListComponentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListContainerRecipesCommandInput extends ListContainerRecipesRe
 }
 export interface ListContainerRecipesCommandOutput extends ListContainerRecipesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of container recipes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListContainerRecipesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListContainerRecipesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListContainerRecipesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListContainerRecipesCommandInput} for command's `input` shape.
- * @see {@link ListContainerRecipesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListContainerRecipesCommand extends $Command<ListContainerRecipesCommandInput, ListContainerRecipesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListContainerRecipesCommandInput;
     constructor(input: ListContainerRecipesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContainerRecipesCommandInput, ListContainerRecipesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListDistributionConfigurationsCommandInput extends ListDistribu
 }
 export interface ListDistributionConfigurationsCommandOutput extends ListDistributionConfigurationsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of distribution configurations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListDistributionConfigurationsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListDistributionConfigurationsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListDistributionConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDistributionConfigurationsCommandInput} for command's `input` shape.
- * @see {@link ListDistributionConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDistributionConfigurationsCommand extends $Command<ListDistributionConfigurationsCommandInput, ListDistributionConfigurationsCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListDistributionConfigurationsCommandInput;
     constructor(input: ListDistributionConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDistributionConfigurationsCommandInput, ListDistributionConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImageBuildVersionsCommandInput extends ListImageBuildVersio
 }
 export interface ListImageBuildVersionsCommandOutput extends ListImageBuildVersionsResponse, __MetadataBearer {
 }
-/**
- * <p> Returns a list of image build versions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImageBuildVersionsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImageBuildVersionsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImageBuildVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImageBuildVersionsCommandInput} for command's `input` shape.
- * @see {@link ListImageBuildVersionsCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImageBuildVersionsCommand extends $Command<ListImageBuildVersionsCommandInput, ListImageBuildVersionsCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImageBuildVersionsCommandInput;
     constructor(input: ListImageBuildVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImageBuildVersionsCommandInput, ListImageBuildVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImagePackagesCommandInput extends ListImagePackagesRequest
 }
 export interface ListImagePackagesCommandOutput extends ListImagePackagesResponse, __MetadataBearer {
 }
-/**
- * <p>List the Packages that are associated with an Image Build Version, as determined by Amazon Web Services Systems Manager Inventory at build time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImagePackagesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImagePackagesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImagePackagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImagePackagesCommandInput} for command's `input` shape.
- * @see {@link ListImagePackagesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImagePackagesCommand extends $Command<ListImagePackagesCommandInput, ListImagePackagesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImagePackagesCommandInput;
     constructor(input: ListImagePackagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImagePackagesCommandInput, ListImagePackagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImagePipelineImagesCommandInput extends ListImagePipelineIm
 }
 export interface ListImagePipelineImagesCommandOutput extends ListImagePipelineImagesResponse, __MetadataBearer {
 }
-/**
- * <p> Returns a list of images created by the specified pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImagePipelineImagesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImagePipelineImagesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImagePipelineImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImagePipelineImagesCommandInput} for command's `input` shape.
- * @see {@link ListImagePipelineImagesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImagePipelineImagesCommand extends $Command<ListImagePipelineImagesCommandInput, ListImagePipelineImagesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImagePipelineImagesCommandInput;
     constructor(input: ListImagePipelineImagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImagePipelineImagesCommandInput, ListImagePipelineImagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImagePipelinesCommandInput extends ListImagePipelinesReques
 }
 export interface ListImagePipelinesCommandOutput extends ListImagePipelinesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of image pipelines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImagePipelinesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImagePipelinesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImagePipelinesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImagePipelinesCommandInput} for command's `input` shape.
- * @see {@link ListImagePipelinesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImagePipelinesCommand extends $Command<ListImagePipelinesCommandInput, ListImagePipelinesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImagePipelinesCommandInput;
     constructor(input: ListImagePipelinesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImagePipelinesCommandInput, ListImagePipelinesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImageRecipesCommandInput extends ListImageRecipesRequest {
 }
 export interface ListImageRecipesCommandOutput extends ListImageRecipesResponse, __MetadataBearer {
 }
-/**
- * <p> Returns a list of image recipes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImageRecipesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImageRecipesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImageRecipesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImageRecipesCommandInput} for command's `input` shape.
- * @see {@link ListImageRecipesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImageRecipesCommand extends $Command<ListImageRecipesCommandInput, ListImageRecipesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImageRecipesCommandInput;
     constructor(input: ListImageRecipesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImageRecipesCommandInput, ListImageRecipesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListImagesCommandInput extends ListImagesRequest {
 }
 export interface ListImagesCommandOutput extends ListImagesResponse, __MetadataBearer {
 }
-/**
- * <p> Returns the list of images that you have access to.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListImagesCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListImagesCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListImagesCommandInput} for command's `input` shape.
- * @see {@link ListImagesCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListImagesCommand extends $Command<ListImagesCommandInput, ListImagesCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListImagesCommandInput;
     constructor(input: ListImagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImagesCommandInput, ListImagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListInfrastructureConfigurationsCommandInput extends ListInfras
 }
 export interface ListInfrastructureConfigurationsCommandOutput extends ListInfrastructureConfigurationsResponse, __MetadataBearer {
 }
-/**
- * <p> Returns a list of infrastructure configurations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, ListInfrastructureConfigurationsCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, ListInfrastructureConfigurationsCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new ListInfrastructureConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListInfrastructureConfigurationsCommandInput} for command's `input` shape.
- * @see {@link ListInfrastructureConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListInfrastructureConfigurationsCommand extends $Command<ListInfrastructureConfigurationsCommandInput, ListInfrastructureConfigurationsCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: ListInfrastructureConfigurationsCommandInput;
     constructor(input: ListInfrastructureConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInfrastructureConfigurationsCommandInput, ListInfrastructureConfigurationsCommandOutput>;
     private serialize;
     private deserialize;