@aws-sdk/client-imagebuilder 3.35.0 → 3.38.0

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

@@ -6,30 +6,11 @@ export interface CreateComponentCommandInput extends CreateComponentRequest {
 }
 export interface CreateComponentCommandOutput extends CreateComponentResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new component that can be used to build, validate, test, and assess your
- * 			image.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateComponentCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateComponentCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateComponentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateComponentCommandInput} for command's `input` shape.
- * @see {@link CreateComponentCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateComponentCommand extends $Command<CreateComponentCommandInput, CreateComponentCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: CreateComponentCommandInput;
     constructor(input: CreateComponentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateComponentCommandInput, CreateComponentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateContainerRecipeCommandInput extends CreateContainerRecipe
 }
 export interface CreateContainerRecipeCommandOutput extends CreateContainerRecipeResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new container recipe. Container recipes define how images are configured, tested, and assessed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateContainerRecipeCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateContainerRecipeCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateContainerRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateContainerRecipeCommandInput} for command's `input` shape.
- * @see {@link CreateContainerRecipeCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateContainerRecipeCommand extends $Command<CreateContainerRecipeCommandInput, CreateContainerRecipeCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: CreateContainerRecipeCommandInput;
     constructor(input: CreateContainerRecipeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerRecipeCommandInput, CreateContainerRecipeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface CreateImageCommandInput extends CreateImageRequest {
 }
 export interface CreateImageCommandOutput extends CreateImageResponse, __MetadataBearer {
 }
-/**
- * <p> Creates a new image. This request will create a new image along with all of the
- * 			configured output resources defined in the distribution configuration. You must specify
- * 			exactly one recipe for your image, using either a ContainerRecipeArn or an ImageRecipeArn.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateImageCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateImageCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageCommandInput} for command's `input` shape.
- * @see {@link CreateImageCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateImageCommand extends $Command<CreateImageCommandInput, CreateImageCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: CreateImageCommandInput;
     constructor(input: CreateImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageCommandInput, CreateImageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface CreateImageRecipeCommandInput extends CreateImageRecipeRequest
 }
 export interface CreateImageRecipeCommandOutput extends CreateImageRecipeResponse, __MetadataBearer {
 }
-/**
- * <p> Creates a new image recipe. Image recipes define how images are configured, tested, and
- * 			assessed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateImageRecipeCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateImageRecipeCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateImageRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageRecipeCommandInput} for command's `input` shape.
- * @see {@link CreateImageRecipeCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateImageRecipeCommand extends $Command<CreateImageRecipeCommandInput, CreateImageRecipeCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: CreateImageRecipeCommandInput;
     constructor(input: CreateImageRecipeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageRecipeCommandInput, CreateImageRecipeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateInfrastructureConfigurationCommandInput extends CreateInf
 }
 export interface CreateInfrastructureConfigurationCommandOutput extends CreateInfrastructureConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p> Creates a new infrastructure configuration. An infrastructure configuration defines the
- * 			environment in which your image will be built and tested.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, CreateInfrastructureConfigurationCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, CreateInfrastructureConfigurationCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new CreateInfrastructureConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInfrastructureConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateInfrastructureConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInfrastructureConfigurationCommand extends $Command<CreateInfrastructureConfigurationCommandInput, CreateInfrastructureConfigurationCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: CreateInfrastructureConfigurationCommandInput;
     constructor(input: CreateInfrastructureConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInfrastructureConfigurationCommandInput, CreateInfrastructureConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,49 +6,11 @@ export interface DeleteImageCommandInput extends DeleteImageRequest {
 }
 export interface DeleteImageCommandOutput extends DeleteImageResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Image Builder image resource. This does not delete any EC2 AMIs or ECR container images
- * 			that are created during the image build process. You must clean those up separately,
- * 			using the appropriate Amazon EC2 or Amazon ECR console actions, or API or CLI commands.</p>
- * 		       <ul>
- *             <li>
- * 				           <p>To deregister an EC2 Linux AMI, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/deregister-ami.html">Deregister
- * 						your Linux AMI</a> in the <i>
- *                      <i>Amazon EC2 User Guide</i>
- *                   </i>.</p>
- * 			         </li>
- *             <li>
- * 				           <p>To deregister an EC2 Windows AMI, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/deregister-ami.html">Deregister
- * 						your Windows AMI</a> in the <i>
- *                      <i>Amazon EC2 Windows Guide</i>
- *                   </i>.</p>
- * 			         </li>
- *             <li>
- * 				           <p>To delete a container image from Amazon ECR, see <a href="https://docs.aws.amazon.com/https:/docs.aws.amazon.comAmazonECR/latest/userguide/delete_image.html">Deleting
- * 						an image</a> in the <i>Amazon ECR User Guide</i>.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ImagebuilderClient, DeleteImageCommand } from "@aws-sdk/client-imagebuilder"; // ES Modules import
- * // const { ImagebuilderClient, DeleteImageCommand } = require("@aws-sdk/client-imagebuilder"); // CommonJS import
- * const client = new ImagebuilderClient(config);
- * const command = new DeleteImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteImageCommandInput} for command's `input` shape.
- * @see {@link DeleteImageCommandOutput} for command's `response` shape.
- * @see {@link ImagebuilderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteImageCommand extends $Command<DeleteImageCommandInput, DeleteImageCommandOutput, ImagebuilderClientResolvedConfig> {
     readonly input: DeleteImageCommandInput;
     constructor(input: DeleteImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ImagebuilderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteImageCommandInput, DeleteImageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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