@aws-sdk/client-imagebuilder 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2349 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ImagebuilderServiceException as __BaseException } from "./ImagebuilderServiceException";
+
+export interface SystemsManagerAgent {
+    
+    uninstallAfterBuild?: boolean;
+}
+export declare namespace SystemsManagerAgent {
+    
+    const filterSensitiveLog: (obj: SystemsManagerAgent) => any;
+}
+
+export interface AdditionalInstanceConfiguration {
+    
+    systemsManagerAgent?: SystemsManagerAgent;
+    
+    userDataOverride?: string;
+}
+export declare namespace AdditionalInstanceConfiguration {
+    
+    const filterSensitiveLog: (obj: AdditionalInstanceConfiguration) => any;
+}
+export declare enum ImageStatus {
+    AVAILABLE = "AVAILABLE",
+    BUILDING = "BUILDING",
+    CANCELLED = "CANCELLED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DEPRECATED = "DEPRECATED",
+    DISTRIBUTING = "DISTRIBUTING",
+    FAILED = "FAILED",
+    INTEGRATING = "INTEGRATING",
+    PENDING = "PENDING",
+    TESTING = "TESTING"
+}
+
+export interface ImageState {
+    
+    status?: ImageStatus | string;
+    
+    reason?: string;
+}
+export declare namespace ImageState {
+    
+    const filterSensitiveLog: (obj: ImageState) => any;
+}
+
+export interface Ami {
+    
+    region?: string;
+    
+    image?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    state?: ImageState;
+    
+    accountId?: string;
+}
+export declare namespace Ami {
+    
+    const filterSensitiveLog: (obj: Ami) => any;
+}
+
+export interface LaunchPermissionConfiguration {
+    
+    userIds?: string[];
+    
+    userGroups?: string[];
+    
+    organizationArns?: string[];
+    
+    organizationalUnitArns?: string[];
+}
+export declare namespace LaunchPermissionConfiguration {
+    
+    const filterSensitiveLog: (obj: LaunchPermissionConfiguration) => any;
+}
+
+export interface AmiDistributionConfiguration {
+    
+    name?: string;
+    
+    description?: string;
+    
+    targetAccountIds?: string[];
+    
+    amiTags?: {
+        [key: string]: string;
+    };
+    
+    kmsKeyId?: string;
+    
+    launchPermission?: LaunchPermissionConfiguration;
+}
+export declare namespace AmiDistributionConfiguration {
+    
+    const filterSensitiveLog: (obj: AmiDistributionConfiguration) => any;
+}
+export declare enum BuildType {
+    IMPORT = "IMPORT",
+    SCHEDULED = "SCHEDULED",
+    USER_INITIATED = "USER_INITIATED"
+}
+
+export declare class CallRateLimitExceededException extends __BaseException {
+    readonly name: "CallRateLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CallRateLimitExceededException, __BaseException>);
+}
+export interface CancelImageCreationRequest {
+    
+    imageBuildVersionArn: string | undefined;
+    
+    clientToken?: string;
+}
+export declare namespace CancelImageCreationRequest {
+    
+    const filterSensitiveLog: (obj: CancelImageCreationRequest) => any;
+}
+export interface CancelImageCreationResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imageBuildVersionArn?: string;
+}
+export declare namespace CancelImageCreationResponse {
+    
+    const filterSensitiveLog: (obj: CancelImageCreationResponse) => any;
+}
+
+export declare class ClientException extends __BaseException {
+    readonly name: "ClientException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClientException, __BaseException>);
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class IdempotentParameterMismatchException extends __BaseException {
+    readonly name: "IdempotentParameterMismatchException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<IdempotentParameterMismatchException, __BaseException>);
+}
+
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+
+export declare class ServiceException extends __BaseException {
+    readonly name: "ServiceException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServiceException, __BaseException>);
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+
+export interface ComponentParameterDetail {
+    
+    name: string | undefined;
+    
+    type: string | undefined;
+    
+    defaultValue?: string[];
+    
+    description?: string;
+}
+export declare namespace ComponentParameterDetail {
+    
+    const filterSensitiveLog: (obj: ComponentParameterDetail) => any;
+}
+export declare enum Platform {
+    LINUX = "Linux",
+    WINDOWS = "Windows"
+}
+export declare enum ComponentStatus {
+    DEPRECATED = "DEPRECATED"
+}
+
+export interface ComponentState {
+    
+    status?: ComponentStatus | string;
+    
+    reason?: string;
+}
+export declare namespace ComponentState {
+    
+    const filterSensitiveLog: (obj: ComponentState) => any;
+}
+export declare enum ComponentType {
+    BUILD = "BUILD",
+    TEST = "TEST"
+}
+
+export interface Component {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    version?: string;
+    
+    description?: string;
+    
+    changeDescription?: string;
+    
+    type?: ComponentType | string;
+    
+    platform?: Platform | string;
+    
+    supportedOsVersions?: string[];
+    
+    state?: ComponentState;
+    
+    parameters?: ComponentParameterDetail[];
+    
+    owner?: string;
+    
+    data?: string;
+    
+    kmsKeyId?: string;
+    
+    encrypted?: boolean;
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Component {
+    
+    const filterSensitiveLog: (obj: Component) => any;
+}
+
+export interface ComponentParameter {
+    
+    name: string | undefined;
+    
+    value: string[] | undefined;
+}
+export declare namespace ComponentParameter {
+    
+    const filterSensitiveLog: (obj: ComponentParameter) => any;
+}
+
+export interface ComponentConfiguration {
+    
+    componentArn: string | undefined;
+    
+    parameters?: ComponentParameter[];
+}
+export declare namespace ComponentConfiguration {
+    
+    const filterSensitiveLog: (obj: ComponentConfiguration) => any;
+}
+export declare enum ComponentFormat {
+    SHELL = "SHELL"
+}
+
+export interface ComponentSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    version?: string;
+    
+    platform?: Platform | string;
+    
+    supportedOsVersions?: string[];
+    
+    state?: ComponentState;
+    
+    type?: ComponentType | string;
+    
+    owner?: string;
+    
+    description?: string;
+    
+    changeDescription?: string;
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ComponentSummary {
+    
+    const filterSensitiveLog: (obj: ComponentSummary) => any;
+}
+
+export interface ComponentVersion {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    version?: string;
+    
+    description?: string;
+    
+    platform?: Platform | string;
+    
+    supportedOsVersions?: string[];
+    
+    type?: ComponentType | string;
+    
+    owner?: string;
+    
+    dateCreated?: string;
+}
+export declare namespace ComponentVersion {
+    
+    const filterSensitiveLog: (obj: ComponentVersion) => any;
+}
+
+export interface Container {
+    
+    region?: string;
+    
+    imageUris?: string[];
+}
+export declare namespace Container {
+    
+    const filterSensitiveLog: (obj: Container) => any;
+}
+export declare enum ContainerRepositoryService {
+    ECR = "ECR"
+}
+
+export interface TargetContainerRepository {
+    
+    service: ContainerRepositoryService | string | undefined;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace TargetContainerRepository {
+    
+    const filterSensitiveLog: (obj: TargetContainerRepository) => any;
+}
+
+export interface ContainerDistributionConfiguration {
+    
+    description?: string;
+    
+    containerTags?: string[];
+    
+    targetRepository: TargetContainerRepository | undefined;
+}
+export declare namespace ContainerDistributionConfiguration {
+    
+    const filterSensitiveLog: (obj: ContainerDistributionConfiguration) => any;
+}
+export declare enum ContainerType {
+    DOCKER = "DOCKER"
+}
+export declare enum EbsVolumeType {
+    GP2 = "gp2",
+    GP3 = "gp3",
+    IO1 = "io1",
+    IO2 = "io2",
+    SC1 = "sc1",
+    ST1 = "st1",
+    STANDARD = "standard"
+}
+
+export interface EbsInstanceBlockDeviceSpecification {
+    
+    encrypted?: boolean;
+    
+    deleteOnTermination?: boolean;
+    
+    iops?: number;
+    
+    kmsKeyId?: string;
+    
+    snapshotId?: string;
+    
+    volumeSize?: number;
+    
+    volumeType?: EbsVolumeType | string;
+    
+    throughput?: number;
+}
+export declare namespace EbsInstanceBlockDeviceSpecification {
+    
+    const filterSensitiveLog: (obj: EbsInstanceBlockDeviceSpecification) => any;
+}
+
+export interface InstanceBlockDeviceMapping {
+    
+    deviceName?: string;
+    
+    ebs?: EbsInstanceBlockDeviceSpecification;
+    
+    virtualName?: string;
+    
+    noDevice?: string;
+}
+export declare namespace InstanceBlockDeviceMapping {
+    
+    const filterSensitiveLog: (obj: InstanceBlockDeviceMapping) => any;
+}
+
+export interface InstanceConfiguration {
+    
+    image?: string;
+    
+    blockDeviceMappings?: InstanceBlockDeviceMapping[];
+}
+export declare namespace InstanceConfiguration {
+    
+    const filterSensitiveLog: (obj: InstanceConfiguration) => any;
+}
+
+export interface ContainerRecipe {
+    
+    arn?: string;
+    
+    containerType?: ContainerType | string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    platform?: Platform | string;
+    
+    owner?: string;
+    
+    version?: string;
+    
+    components?: ComponentConfiguration[];
+    
+    instanceConfiguration?: InstanceConfiguration;
+    
+    dockerfileTemplateData?: string;
+    
+    kmsKeyId?: string;
+    
+    encrypted?: boolean;
+    
+    parentImage?: string;
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    workingDirectory?: string;
+    
+    targetRepository?: TargetContainerRepository;
+}
+export declare namespace ContainerRecipe {
+    
+    const filterSensitiveLog: (obj: ContainerRecipe) => any;
+}
+
+export interface ContainerRecipeSummary {
+    
+    arn?: string;
+    
+    containerType?: ContainerType | string;
+    
+    name?: string;
+    
+    platform?: Platform | string;
+    
+    owner?: string;
+    
+    parentImage?: string;
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ContainerRecipeSummary {
+    
+    const filterSensitiveLog: (obj: ContainerRecipeSummary) => any;
+}
+export interface CreateComponentRequest {
+    
+    name: string | undefined;
+    
+    semanticVersion: string | undefined;
+    
+    description?: string;
+    
+    changeDescription?: string;
+    
+    platform: Platform | string | undefined;
+    
+    supportedOsVersions?: string[];
+    
+    data?: string;
+    
+    uri?: string;
+    
+    kmsKeyId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace CreateComponentRequest {
+    
+    const filterSensitiveLog: (obj: CreateComponentRequest) => any;
+}
+export interface CreateComponentResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    componentBuildVersionArn?: string;
+}
+export declare namespace CreateComponentResponse {
+    
+    const filterSensitiveLog: (obj: CreateComponentResponse) => any;
+}
+
+export declare class InvalidParameterCombinationException extends __BaseException {
+    readonly name: "InvalidParameterCombinationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterCombinationException, __BaseException>);
+}
+
+export declare class InvalidVersionNumberException extends __BaseException {
+    readonly name: "InvalidVersionNumberException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidVersionNumberException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+export interface CreateContainerRecipeRequest {
+    
+    containerType: ContainerType | string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    semanticVersion: string | undefined;
+    
+    components: ComponentConfiguration[] | undefined;
+    
+    instanceConfiguration?: InstanceConfiguration;
+    
+    dockerfileTemplateData?: string;
+    
+    dockerfileTemplateUri?: string;
+    
+    platformOverride?: Platform | string;
+    
+    imageOsVersionOverride?: string;
+    
+    parentImage: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    workingDirectory?: string;
+    
+    targetRepository: TargetContainerRepository | undefined;
+    
+    kmsKeyId?: string;
+    
+    clientToken?: string;
+}
+export declare namespace CreateContainerRecipeRequest {
+    
+    const filterSensitiveLog: (obj: CreateContainerRecipeRequest) => any;
+}
+export interface CreateContainerRecipeResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    containerRecipeArn?: string;
+}
+export declare namespace CreateContainerRecipeResponse {
+    
+    const filterSensitiveLog: (obj: CreateContainerRecipeResponse) => any;
+}
+
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+
+export interface FastLaunchLaunchTemplateSpecification {
+    
+    launchTemplateId?: string;
+    
+    launchTemplateName?: string;
+    
+    launchTemplateVersion?: string;
+}
+export declare namespace FastLaunchLaunchTemplateSpecification {
+    
+    const filterSensitiveLog: (obj: FastLaunchLaunchTemplateSpecification) => any;
+}
+
+export interface FastLaunchSnapshotConfiguration {
+    
+    targetResourceCount?: number;
+}
+export declare namespace FastLaunchSnapshotConfiguration {
+    
+    const filterSensitiveLog: (obj: FastLaunchSnapshotConfiguration) => any;
+}
+
+export interface FastLaunchConfiguration {
+    
+    enabled: boolean | undefined;
+    
+    snapshotConfiguration?: FastLaunchSnapshotConfiguration;
+    
+    maxParallelLaunches?: number;
+    
+    launchTemplate?: FastLaunchLaunchTemplateSpecification;
+    
+    accountId?: string;
+}
+export declare namespace FastLaunchConfiguration {
+    
+    const filterSensitiveLog: (obj: FastLaunchConfiguration) => any;
+}
+
+export interface LaunchTemplateConfiguration {
+    
+    launchTemplateId: string | undefined;
+    
+    accountId?: string;
+    
+    setDefaultVersion?: boolean;
+}
+export declare namespace LaunchTemplateConfiguration {
+    
+    const filterSensitiveLog: (obj: LaunchTemplateConfiguration) => any;
+}
+export declare enum DiskImageFormat {
+    RAW = "RAW",
+    VHD = "VHD",
+    VMDK = "VMDK"
+}
+
+export interface S3ExportConfiguration {
+    
+    roleName: string | undefined;
+    
+    diskImageFormat: DiskImageFormat | string | undefined;
+    
+    s3Bucket: string | undefined;
+    
+    s3Prefix?: string;
+}
+export declare namespace S3ExportConfiguration {
+    
+    const filterSensitiveLog: (obj: S3ExportConfiguration) => any;
+}
+
+export interface Distribution {
+    
+    region: string | undefined;
+    
+    amiDistributionConfiguration?: AmiDistributionConfiguration;
+    
+    containerDistributionConfiguration?: ContainerDistributionConfiguration;
+    
+    licenseConfigurationArns?: string[];
+    
+    launchTemplateConfigurations?: LaunchTemplateConfiguration[];
+    
+    s3ExportConfiguration?: S3ExportConfiguration;
+    
+    fastLaunchConfigurations?: FastLaunchConfiguration[];
+}
+export declare namespace Distribution {
+    
+    const filterSensitiveLog: (obj: Distribution) => any;
+}
+export interface CreateDistributionConfigurationRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    distributions: Distribution[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace CreateDistributionConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateDistributionConfigurationRequest) => any;
+}
+export interface CreateDistributionConfigurationResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    distributionConfigurationArn?: string;
+}
+export declare namespace CreateDistributionConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateDistributionConfigurationResponse) => any;
+}
+
+export interface ImageTestsConfiguration {
+    
+    imageTestsEnabled?: boolean;
+    
+    timeoutMinutes?: number;
+}
+export declare namespace ImageTestsConfiguration {
+    
+    const filterSensitiveLog: (obj: ImageTestsConfiguration) => any;
+}
+export interface CreateImageRequest {
+    
+    imageRecipeArn?: string;
+    
+    containerRecipeArn?: string;
+    
+    distributionConfigurationArn?: string;
+    
+    infrastructureConfigurationArn: string | undefined;
+    
+    imageTestsConfiguration?: ImageTestsConfiguration;
+    
+    enhancedImageMetadataEnabled?: boolean;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace CreateImageRequest {
+    
+    const filterSensitiveLog: (obj: CreateImageRequest) => any;
+}
+export interface CreateImageResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imageBuildVersionArn?: string;
+}
+export declare namespace CreateImageResponse {
+    
+    const filterSensitiveLog: (obj: CreateImageResponse) => any;
+}
+export declare enum PipelineExecutionStartCondition {
+    EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE = "EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE",
+    EXPRESSION_MATCH_ONLY = "EXPRESSION_MATCH_ONLY"
+}
+
+export interface Schedule {
+    
+    scheduleExpression?: string;
+    
+    timezone?: string;
+    
+    pipelineExecutionStartCondition?: PipelineExecutionStartCondition | string;
+}
+export declare namespace Schedule {
+    
+    const filterSensitiveLog: (obj: Schedule) => any;
+}
+export declare enum PipelineStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export interface CreateImagePipelineRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    imageRecipeArn?: string;
+    
+    containerRecipeArn?: string;
+    
+    infrastructureConfigurationArn: string | undefined;
+    
+    distributionConfigurationArn?: string;
+    
+    imageTestsConfiguration?: ImageTestsConfiguration;
+    
+    enhancedImageMetadataEnabled?: boolean;
+    
+    schedule?: Schedule;
+    
+    status?: PipelineStatus | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace CreateImagePipelineRequest {
+    
+    const filterSensitiveLog: (obj: CreateImagePipelineRequest) => any;
+}
+export interface CreateImagePipelineResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imagePipelineArn?: string;
+}
+export declare namespace CreateImagePipelineResponse {
+    
+    const filterSensitiveLog: (obj: CreateImagePipelineResponse) => any;
+}
+export interface CreateImageRecipeRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    semanticVersion: string | undefined;
+    
+    components: ComponentConfiguration[] | undefined;
+    
+    parentImage: string | undefined;
+    
+    blockDeviceMappings?: InstanceBlockDeviceMapping[];
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    workingDirectory?: string;
+    
+    additionalInstanceConfiguration?: AdditionalInstanceConfiguration;
+    
+    clientToken?: string;
+}
+export declare namespace CreateImageRecipeRequest {
+    
+    const filterSensitiveLog: (obj: CreateImageRecipeRequest) => any;
+}
+export interface CreateImageRecipeResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imageRecipeArn?: string;
+}
+export declare namespace CreateImageRecipeResponse {
+    
+    const filterSensitiveLog: (obj: CreateImageRecipeResponse) => any;
+}
+
+export interface InstanceMetadataOptions {
+    
+    httpTokens?: string;
+    
+    httpPutResponseHopLimit?: number;
+}
+export declare namespace InstanceMetadataOptions {
+    
+    const filterSensitiveLog: (obj: InstanceMetadataOptions) => any;
+}
+
+export interface S3Logs {
+    
+    s3BucketName?: string;
+    
+    s3KeyPrefix?: string;
+}
+export declare namespace S3Logs {
+    
+    const filterSensitiveLog: (obj: S3Logs) => any;
+}
+
+export interface Logging {
+    
+    s3Logs?: S3Logs;
+}
+export declare namespace Logging {
+    
+    const filterSensitiveLog: (obj: Logging) => any;
+}
+export interface CreateInfrastructureConfigurationRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    instanceTypes?: string[];
+    
+    instanceProfileName: string | undefined;
+    
+    securityGroupIds?: string[];
+    
+    subnetId?: string;
+    
+    logging?: Logging;
+    
+    keyPair?: string;
+    
+    terminateInstanceOnFailure?: boolean;
+    
+    snsTopicArn?: string;
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    instanceMetadataOptions?: InstanceMetadataOptions;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace CreateInfrastructureConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateInfrastructureConfigurationRequest) => any;
+}
+export interface CreateInfrastructureConfigurationResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    infrastructureConfigurationArn?: string;
+}
+export declare namespace CreateInfrastructureConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateInfrastructureConfigurationResponse) => any;
+}
+export interface DeleteComponentRequest {
+    
+    componentBuildVersionArn: string | undefined;
+}
+export declare namespace DeleteComponentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteComponentRequest) => any;
+}
+export interface DeleteComponentResponse {
+    
+    requestId?: string;
+    
+    componentBuildVersionArn?: string;
+}
+export declare namespace DeleteComponentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteComponentResponse) => any;
+}
+
+export declare class ResourceDependencyException extends __BaseException {
+    readonly name: "ResourceDependencyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceDependencyException, __BaseException>);
+}
+export interface DeleteContainerRecipeRequest {
+    
+    containerRecipeArn: string | undefined;
+}
+export declare namespace DeleteContainerRecipeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteContainerRecipeRequest) => any;
+}
+export interface DeleteContainerRecipeResponse {
+    
+    requestId?: string;
+    
+    containerRecipeArn?: string;
+}
+export declare namespace DeleteContainerRecipeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteContainerRecipeResponse) => any;
+}
+export interface DeleteDistributionConfigurationRequest {
+    
+    distributionConfigurationArn: string | undefined;
+}
+export declare namespace DeleteDistributionConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDistributionConfigurationRequest) => any;
+}
+export interface DeleteDistributionConfigurationResponse {
+    
+    requestId?: string;
+    
+    distributionConfigurationArn?: string;
+}
+export declare namespace DeleteDistributionConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDistributionConfigurationResponse) => any;
+}
+export interface DeleteImageRequest {
+    
+    imageBuildVersionArn: string | undefined;
+}
+export declare namespace DeleteImageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageRequest) => any;
+}
+export interface DeleteImageResponse {
+    
+    requestId?: string;
+    
+    imageBuildVersionArn?: string;
+}
+export declare namespace DeleteImageResponse {
+    
+    const filterSensitiveLog: (obj: DeleteImageResponse) => any;
+}
+export interface DeleteImagePipelineRequest {
+    
+    imagePipelineArn: string | undefined;
+}
+export declare namespace DeleteImagePipelineRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImagePipelineRequest) => any;
+}
+export interface DeleteImagePipelineResponse {
+    
+    requestId?: string;
+    
+    imagePipelineArn?: string;
+}
+export declare namespace DeleteImagePipelineResponse {
+    
+    const filterSensitiveLog: (obj: DeleteImagePipelineResponse) => any;
+}
+export interface DeleteImageRecipeRequest {
+    
+    imageRecipeArn: string | undefined;
+}
+export declare namespace DeleteImageRecipeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageRecipeRequest) => any;
+}
+export interface DeleteImageRecipeResponse {
+    
+    requestId?: string;
+    
+    imageRecipeArn?: string;
+}
+export declare namespace DeleteImageRecipeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteImageRecipeResponse) => any;
+}
+export interface DeleteInfrastructureConfigurationRequest {
+    
+    infrastructureConfigurationArn: string | undefined;
+}
+export declare namespace DeleteInfrastructureConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInfrastructureConfigurationRequest) => any;
+}
+export interface DeleteInfrastructureConfigurationResponse {
+    
+    requestId?: string;
+    
+    infrastructureConfigurationArn?: string;
+}
+export declare namespace DeleteInfrastructureConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInfrastructureConfigurationResponse) => any;
+}
+
+export interface DistributionConfiguration {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    distributions?: Distribution[];
+    
+    timeoutMinutes: number | undefined;
+    
+    dateCreated?: string;
+    
+    dateUpdated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DistributionConfiguration {
+    
+    const filterSensitiveLog: (obj: DistributionConfiguration) => any;
+}
+
+export interface DistributionConfigurationSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    dateCreated?: string;
+    
+    dateUpdated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    regions?: string[];
+}
+export declare namespace DistributionConfigurationSummary {
+    
+    const filterSensitiveLog: (obj: DistributionConfigurationSummary) => any;
+}
+
+export interface Filter {
+    
+    name?: string;
+    
+    values?: string[];
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+export interface GetComponentRequest {
+    
+    componentBuildVersionArn: string | undefined;
+}
+export declare namespace GetComponentRequest {
+    
+    const filterSensitiveLog: (obj: GetComponentRequest) => any;
+}
+export interface GetComponentResponse {
+    
+    requestId?: string;
+    
+    component?: Component;
+}
+export declare namespace GetComponentResponse {
+    
+    const filterSensitiveLog: (obj: GetComponentResponse) => any;
+}
+export interface GetComponentPolicyRequest {
+    
+    componentArn: string | undefined;
+}
+export declare namespace GetComponentPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetComponentPolicyRequest) => any;
+}
+export interface GetComponentPolicyResponse {
+    
+    requestId?: string;
+    
+    policy?: string;
+}
+export declare namespace GetComponentPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetComponentPolicyResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface GetContainerRecipeRequest {
+    
+    containerRecipeArn: string | undefined;
+}
+export declare namespace GetContainerRecipeRequest {
+    
+    const filterSensitiveLog: (obj: GetContainerRecipeRequest) => any;
+}
+export interface GetContainerRecipeResponse {
+    
+    requestId?: string;
+    
+    containerRecipe?: ContainerRecipe;
+}
+export declare namespace GetContainerRecipeResponse {
+    
+    const filterSensitiveLog: (obj: GetContainerRecipeResponse) => any;
+}
+export interface GetContainerRecipePolicyRequest {
+    
+    containerRecipeArn: string | undefined;
+}
+export declare namespace GetContainerRecipePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetContainerRecipePolicyRequest) => any;
+}
+export interface GetContainerRecipePolicyResponse {
+    
+    requestId?: string;
+    
+    policy?: string;
+}
+export declare namespace GetContainerRecipePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetContainerRecipePolicyResponse) => any;
+}
+export interface GetDistributionConfigurationRequest {
+    
+    distributionConfigurationArn: string | undefined;
+}
+export declare namespace GetDistributionConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetDistributionConfigurationRequest) => any;
+}
+export interface GetDistributionConfigurationResponse {
+    
+    requestId?: string;
+    
+    distributionConfiguration?: DistributionConfiguration;
+}
+export declare namespace GetDistributionConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetDistributionConfigurationResponse) => any;
+}
+export interface GetImageRequest {
+    
+    imageBuildVersionArn: string | undefined;
+}
+export declare namespace GetImageRequest {
+    
+    const filterSensitiveLog: (obj: GetImageRequest) => any;
+}
+export declare enum ImageType {
+    AMI = "AMI",
+    DOCKER = "DOCKER"
+}
+
+export interface ImageRecipe {
+    
+    arn?: string;
+    
+    type?: ImageType | string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    platform?: Platform | string;
+    
+    owner?: string;
+    
+    version?: string;
+    
+    components?: ComponentConfiguration[];
+    
+    parentImage?: string;
+    
+    blockDeviceMappings?: InstanceBlockDeviceMapping[];
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    workingDirectory?: string;
+    
+    additionalInstanceConfiguration?: AdditionalInstanceConfiguration;
+}
+export declare namespace ImageRecipe {
+    
+    const filterSensitiveLog: (obj: ImageRecipe) => any;
+}
+
+export interface InfrastructureConfiguration {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    instanceTypes?: string[];
+    
+    instanceProfileName?: string;
+    
+    securityGroupIds?: string[];
+    
+    subnetId?: string;
+    
+    logging?: Logging;
+    
+    keyPair?: string;
+    
+    terminateInstanceOnFailure?: boolean;
+    
+    snsTopicArn?: string;
+    
+    dateCreated?: string;
+    
+    dateUpdated?: string;
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    instanceMetadataOptions?: InstanceMetadataOptions;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace InfrastructureConfiguration {
+    
+    const filterSensitiveLog: (obj: InfrastructureConfiguration) => any;
+}
+
+export interface OutputResources {
+    
+    amis?: Ami[];
+    
+    containers?: Container[];
+}
+export declare namespace OutputResources {
+    
+    const filterSensitiveLog: (obj: OutputResources) => any;
+}
+
+export interface Image {
+    
+    arn?: string;
+    
+    type?: ImageType | string;
+    
+    name?: string;
+    
+    version?: string;
+    
+    platform?: Platform | string;
+    
+    enhancedImageMetadataEnabled?: boolean;
+    
+    osVersion?: string;
+    
+    state?: ImageState;
+    
+    imageRecipe?: ImageRecipe;
+    
+    containerRecipe?: ContainerRecipe;
+    
+    sourcePipelineName?: string;
+    
+    sourcePipelineArn?: string;
+    
+    infrastructureConfiguration?: InfrastructureConfiguration;
+    
+    distributionConfiguration?: DistributionConfiguration;
+    
+    imageTestsConfiguration?: ImageTestsConfiguration;
+    
+    dateCreated?: string;
+    
+    outputResources?: OutputResources;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    buildType?: BuildType | string;
+}
+export declare namespace Image {
+    
+    const filterSensitiveLog: (obj: Image) => any;
+}
+export interface GetImageResponse {
+    
+    requestId?: string;
+    
+    image?: Image;
+}
+export declare namespace GetImageResponse {
+    
+    const filterSensitiveLog: (obj: GetImageResponse) => any;
+}
+export interface GetImagePipelineRequest {
+    
+    imagePipelineArn: string | undefined;
+}
+export declare namespace GetImagePipelineRequest {
+    
+    const filterSensitiveLog: (obj: GetImagePipelineRequest) => any;
+}
+
+export interface ImagePipeline {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    platform?: Platform | string;
+    
+    enhancedImageMetadataEnabled?: boolean;
+    
+    imageRecipeArn?: string;
+    
+    containerRecipeArn?: string;
+    
+    infrastructureConfigurationArn?: string;
+    
+    distributionConfigurationArn?: string;
+    
+    imageTestsConfiguration?: ImageTestsConfiguration;
+    
+    schedule?: Schedule;
+    
+    status?: PipelineStatus | string;
+    
+    dateCreated?: string;
+    
+    dateUpdated?: string;
+    
+    dateLastRun?: string;
+    
+    dateNextRun?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ImagePipeline {
+    
+    const filterSensitiveLog: (obj: ImagePipeline) => any;
+}
+export interface GetImagePipelineResponse {
+    
+    requestId?: string;
+    
+    imagePipeline?: ImagePipeline;
+}
+export declare namespace GetImagePipelineResponse {
+    
+    const filterSensitiveLog: (obj: GetImagePipelineResponse) => any;
+}
+export interface GetImagePolicyRequest {
+    
+    imageArn: string | undefined;
+}
+export declare namespace GetImagePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetImagePolicyRequest) => any;
+}
+export interface GetImagePolicyResponse {
+    
+    requestId?: string;
+    
+    policy?: string;
+}
+export declare namespace GetImagePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetImagePolicyResponse) => any;
+}
+export interface GetImageRecipeRequest {
+    
+    imageRecipeArn: string | undefined;
+}
+export declare namespace GetImageRecipeRequest {
+    
+    const filterSensitiveLog: (obj: GetImageRecipeRequest) => any;
+}
+export interface GetImageRecipeResponse {
+    
+    requestId?: string;
+    
+    imageRecipe?: ImageRecipe;
+}
+export declare namespace GetImageRecipeResponse {
+    
+    const filterSensitiveLog: (obj: GetImageRecipeResponse) => any;
+}
+export interface GetImageRecipePolicyRequest {
+    
+    imageRecipeArn: string | undefined;
+}
+export declare namespace GetImageRecipePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetImageRecipePolicyRequest) => any;
+}
+export interface GetImageRecipePolicyResponse {
+    
+    requestId?: string;
+    
+    policy?: string;
+}
+export declare namespace GetImageRecipePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetImageRecipePolicyResponse) => any;
+}
+
+export interface GetInfrastructureConfigurationRequest {
+    
+    infrastructureConfigurationArn: string | undefined;
+}
+export declare namespace GetInfrastructureConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetInfrastructureConfigurationRequest) => any;
+}
+
+export interface GetInfrastructureConfigurationResponse {
+    
+    requestId?: string;
+    
+    infrastructureConfiguration?: InfrastructureConfiguration;
+}
+export declare namespace GetInfrastructureConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetInfrastructureConfigurationResponse) => any;
+}
+export interface ImportComponentRequest {
+    
+    name: string | undefined;
+    
+    semanticVersion: string | undefined;
+    
+    description?: string;
+    
+    changeDescription?: string;
+    
+    type: ComponentType | string | undefined;
+    
+    format: ComponentFormat | string | undefined;
+    
+    platform: Platform | string | undefined;
+    
+    data?: string;
+    
+    uri?: string;
+    
+    kmsKeyId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace ImportComponentRequest {
+    
+    const filterSensitiveLog: (obj: ImportComponentRequest) => any;
+}
+export interface ImportComponentResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    componentBuildVersionArn?: string;
+}
+export declare namespace ImportComponentResponse {
+    
+    const filterSensitiveLog: (obj: ImportComponentResponse) => any;
+}
+export interface ImportVmImageRequest {
+    
+    name: string | undefined;
+    
+    semanticVersion: string | undefined;
+    
+    description?: string;
+    
+    platform: Platform | string | undefined;
+    
+    osVersion?: string;
+    
+    vmImportTaskId: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientToken?: string;
+}
+export declare namespace ImportVmImageRequest {
+    
+    const filterSensitiveLog: (obj: ImportVmImageRequest) => any;
+}
+export interface ImportVmImageResponse {
+    
+    requestId?: string;
+    
+    imageArn?: string;
+    
+    clientToken?: string;
+}
+export declare namespace ImportVmImageResponse {
+    
+    const filterSensitiveLog: (obj: ImportVmImageResponse) => any;
+}
+
+export declare class InvalidPaginationTokenException extends __BaseException {
+    readonly name: "InvalidPaginationTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPaginationTokenException, __BaseException>);
+}
+export interface ListComponentBuildVersionsRequest {
+    
+    componentVersionArn: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListComponentBuildVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListComponentBuildVersionsRequest) => any;
+}
+export interface ListComponentBuildVersionsResponse {
+    
+    requestId?: string;
+    
+    componentSummaryList?: ComponentSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListComponentBuildVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListComponentBuildVersionsResponse) => any;
+}
+export declare enum Ownership {
+    AMAZON = "Amazon",
+    SELF = "Self",
+    SHARED = "Shared"
+}
+export interface ListComponentsRequest {
+    
+    owner?: Ownership | string;
+    
+    filters?: Filter[];
+    
+    byName?: boolean;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListComponentsRequest {
+    
+    const filterSensitiveLog: (obj: ListComponentsRequest) => any;
+}
+export interface ListComponentsResponse {
+    
+    requestId?: string;
+    
+    componentVersionList?: ComponentVersion[];
+    
+    nextToken?: string;
+}
+export declare namespace ListComponentsResponse {
+    
+    const filterSensitiveLog: (obj: ListComponentsResponse) => any;
+}
+export interface ListContainerRecipesRequest {
+    
+    owner?: Ownership | string;
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListContainerRecipesRequest {
+    
+    const filterSensitiveLog: (obj: ListContainerRecipesRequest) => any;
+}
+export interface ListContainerRecipesResponse {
+    
+    requestId?: string;
+    
+    containerRecipeSummaryList?: ContainerRecipeSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListContainerRecipesResponse {
+    
+    const filterSensitiveLog: (obj: ListContainerRecipesResponse) => any;
+}
+export interface ListDistributionConfigurationsRequest {
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListDistributionConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListDistributionConfigurationsRequest) => any;
+}
+export interface ListDistributionConfigurationsResponse {
+    
+    requestId?: string;
+    
+    distributionConfigurationSummaryList?: DistributionConfigurationSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDistributionConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListDistributionConfigurationsResponse) => any;
+}
+export interface ListImageBuildVersionsRequest {
+    
+    imageVersionArn: string | undefined;
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListImageBuildVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListImageBuildVersionsRequest) => any;
+}
+
+export interface ImageSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: ImageType | string;
+    
+    version?: string;
+    
+    platform?: Platform | string;
+    
+    osVersion?: string;
+    
+    state?: ImageState;
+    
+    owner?: string;
+    
+    dateCreated?: string;
+    
+    outputResources?: OutputResources;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    buildType?: BuildType | string;
+}
+export declare namespace ImageSummary {
+    
+    const filterSensitiveLog: (obj: ImageSummary) => any;
+}
+export interface ListImageBuildVersionsResponse {
+    
+    requestId?: string;
+    
+    imageSummaryList?: ImageSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImageBuildVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListImageBuildVersionsResponse) => any;
+}
+export interface ListImagePackagesRequest {
+    
+    imageBuildVersionArn: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePackagesRequest {
+    
+    const filterSensitiveLog: (obj: ListImagePackagesRequest) => any;
+}
+
+export interface ImagePackage {
+    
+    packageName?: string;
+    
+    packageVersion?: string;
+}
+export declare namespace ImagePackage {
+    
+    const filterSensitiveLog: (obj: ImagePackage) => any;
+}
+export interface ListImagePackagesResponse {
+    
+    requestId?: string;
+    
+    imagePackageList?: ImagePackage[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePackagesResponse {
+    
+    const filterSensitiveLog: (obj: ListImagePackagesResponse) => any;
+}
+export interface ListImagePipelineImagesRequest {
+    
+    imagePipelineArn: string | undefined;
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePipelineImagesRequest {
+    
+    const filterSensitiveLog: (obj: ListImagePipelineImagesRequest) => any;
+}
+export interface ListImagePipelineImagesResponse {
+    
+    requestId?: string;
+    
+    imageSummaryList?: ImageSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePipelineImagesResponse {
+    
+    const filterSensitiveLog: (obj: ListImagePipelineImagesResponse) => any;
+}
+export interface ListImagePipelinesRequest {
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePipelinesRequest {
+    
+    const filterSensitiveLog: (obj: ListImagePipelinesRequest) => any;
+}
+export interface ListImagePipelinesResponse {
+    
+    requestId?: string;
+    
+    imagePipelineList?: ImagePipeline[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImagePipelinesResponse {
+    
+    const filterSensitiveLog: (obj: ListImagePipelinesResponse) => any;
+}
+export interface ListImageRecipesRequest {
+    
+    owner?: Ownership | string;
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListImageRecipesRequest {
+    
+    const filterSensitiveLog: (obj: ListImageRecipesRequest) => any;
+}
+
+export interface ImageRecipeSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    platform?: Platform | string;
+    
+    owner?: string;
+    
+    parentImage?: string;
+    
+    dateCreated?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ImageRecipeSummary {
+    
+    const filterSensitiveLog: (obj: ImageRecipeSummary) => any;
+}
+export interface ListImageRecipesResponse {
+    
+    requestId?: string;
+    
+    imageRecipeSummaryList?: ImageRecipeSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImageRecipesResponse {
+    
+    const filterSensitiveLog: (obj: ListImageRecipesResponse) => any;
+}
+export interface ListImagesRequest {
+    
+    owner?: Ownership | string;
+    
+    filters?: Filter[];
+    
+    byName?: boolean;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    includeDeprecated?: boolean;
+}
+export declare namespace ListImagesRequest {
+    
+    const filterSensitiveLog: (obj: ListImagesRequest) => any;
+}
+
+export interface ImageVersion {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: ImageType | string;
+    
+    version?: string;
+    
+    platform?: Platform | string;
+    
+    osVersion?: string;
+    
+    owner?: string;
+    
+    dateCreated?: string;
+    
+    buildType?: BuildType | string;
+}
+export declare namespace ImageVersion {
+    
+    const filterSensitiveLog: (obj: ImageVersion) => any;
+}
+export interface ListImagesResponse {
+    
+    requestId?: string;
+    
+    imageVersionList?: ImageVersion[];
+    
+    nextToken?: string;
+}
+export declare namespace ListImagesResponse {
+    
+    const filterSensitiveLog: (obj: ListImagesResponse) => any;
+}
+export interface ListInfrastructureConfigurationsRequest {
+    
+    filters?: Filter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListInfrastructureConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListInfrastructureConfigurationsRequest) => any;
+}
+
+export interface InfrastructureConfigurationSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    dateCreated?: string;
+    
+    dateUpdated?: string;
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    instanceTypes?: string[];
+    
+    instanceProfileName?: string;
+}
+export declare namespace InfrastructureConfigurationSummary {
+    
+    const filterSensitiveLog: (obj: InfrastructureConfigurationSummary) => any;
+}
+export interface ListInfrastructureConfigurationsResponse {
+    
+    requestId?: string;
+    
+    infrastructureConfigurationSummaryList?: InfrastructureConfigurationSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListInfrastructureConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListInfrastructureConfigurationsResponse) => any;
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export declare class InvalidParameterValueException extends __BaseException {
+    readonly name: "InvalidParameterValueException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>);
+}
+export interface PutComponentPolicyRequest {
+    
+    componentArn: string | undefined;
+    
+    policy: string | undefined;
+}
+export declare namespace PutComponentPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutComponentPolicyRequest) => any;
+}
+export interface PutComponentPolicyResponse {
+    
+    requestId?: string;
+    
+    componentArn?: string;
+}
+export declare namespace PutComponentPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutComponentPolicyResponse) => any;
+}
+export interface PutContainerRecipePolicyRequest {
+    
+    containerRecipeArn: string | undefined;
+    
+    policy: string | undefined;
+}
+export declare namespace PutContainerRecipePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutContainerRecipePolicyRequest) => any;
+}
+export interface PutContainerRecipePolicyResponse {
+    
+    requestId?: string;
+    
+    containerRecipeArn?: string;
+}
+export declare namespace PutContainerRecipePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutContainerRecipePolicyResponse) => any;
+}
+export interface PutImagePolicyRequest {
+    
+    imageArn: string | undefined;
+    
+    policy: string | undefined;
+}
+export declare namespace PutImagePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutImagePolicyRequest) => any;
+}
+export interface PutImagePolicyResponse {
+    
+    requestId?: string;
+    
+    imageArn?: string;
+}
+export declare namespace PutImagePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutImagePolicyResponse) => any;
+}
+export interface PutImageRecipePolicyRequest {
+    
+    imageRecipeArn: string | undefined;
+    
+    policy: string | undefined;
+}
+export declare namespace PutImageRecipePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutImageRecipePolicyRequest) => any;
+}
+export interface PutImageRecipePolicyResponse {
+    
+    requestId?: string;
+    
+    imageRecipeArn?: string;
+}
+export declare namespace PutImageRecipePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutImageRecipePolicyResponse) => any;
+}
+export interface StartImagePipelineExecutionRequest {
+    
+    imagePipelineArn: string | undefined;
+    
+    clientToken?: string;
+}
+export declare namespace StartImagePipelineExecutionRequest {
+    
+    const filterSensitiveLog: (obj: StartImagePipelineExecutionRequest) => any;
+}
+export interface StartImagePipelineExecutionResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imageBuildVersionArn?: string;
+}
+export declare namespace StartImagePipelineExecutionResponse {
+    
+    const filterSensitiveLog: (obj: StartImagePipelineExecutionResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateDistributionConfigurationRequest {
+    
+    distributionConfigurationArn: string | undefined;
+    
+    description?: string;
+    
+    distributions: Distribution[] | undefined;
+    
+    clientToken?: string;
+}
+export declare namespace UpdateDistributionConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDistributionConfigurationRequest) => any;
+}
+export interface UpdateDistributionConfigurationResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    distributionConfigurationArn?: string;
+}
+export declare namespace UpdateDistributionConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDistributionConfigurationResponse) => any;
+}
+export interface UpdateImagePipelineRequest {
+    
+    imagePipelineArn: string | undefined;
+    
+    description?: string;
+    
+    imageRecipeArn?: string;
+    
+    containerRecipeArn?: string;
+    
+    infrastructureConfigurationArn: string | undefined;
+    
+    distributionConfigurationArn?: string;
+    
+    imageTestsConfiguration?: ImageTestsConfiguration;
+    
+    enhancedImageMetadataEnabled?: boolean;
+    
+    schedule?: Schedule;
+    
+    status?: PipelineStatus | string;
+    
+    clientToken?: string;
+}
+export declare namespace UpdateImagePipelineRequest {
+    
+    const filterSensitiveLog: (obj: UpdateImagePipelineRequest) => any;
+}
+export interface UpdateImagePipelineResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    imagePipelineArn?: string;
+}
+export declare namespace UpdateImagePipelineResponse {
+    
+    const filterSensitiveLog: (obj: UpdateImagePipelineResponse) => any;
+}
+export interface UpdateInfrastructureConfigurationRequest {
+    
+    infrastructureConfigurationArn: string | undefined;
+    
+    description?: string;
+    
+    instanceTypes?: string[];
+    
+    instanceProfileName: string | undefined;
+    
+    securityGroupIds?: string[];
+    
+    subnetId?: string;
+    
+    logging?: Logging;
+    
+    keyPair?: string;
+    
+    terminateInstanceOnFailure?: boolean;
+    
+    snsTopicArn?: string;
+    
+    clientToken?: string;
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    instanceMetadataOptions?: InstanceMetadataOptions;
+}
+export declare namespace UpdateInfrastructureConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInfrastructureConfigurationRequest) => any;
+}
+export interface UpdateInfrastructureConfigurationResponse {
+    
+    requestId?: string;
+    
+    clientToken?: string;
+    
+    infrastructureConfigurationArn?: string;
+}
+export declare namespace UpdateInfrastructureConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateInfrastructureConfigurationResponse) => any;
+}