agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-batch/lib/compute-environment-base.d.ts

@@ -0,0 +1,90 @@
+import type { Construct } from 'constructs';
+import type * as iam from '../../aws-iam';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+import type { ComputeEnvironmentReference, IComputeEnvironmentRef } from '../../interfaces/generated/aws-batch-interfaces.generated';
+/**
+ * Represents a ComputeEnvironment
+ */
+export interface IComputeEnvironment extends IResource, IComputeEnvironmentRef {
+    /**
+     * The name of the ComputeEnvironment
+     *
+     * @attribute
+     */
+    readonly computeEnvironmentName: string;
+    /**
+     * The ARN of this compute environment.
+     *
+     * @attribute
+     */
+    readonly computeEnvironmentArn: string;
+    /**
+     * The role Batch uses to perform actions on your behalf
+     * in your account, such as provision instances to run your jobs
+     *
+     * @default - a serviceRole will be created for managed CEs, none for unmanaged CEs
+     */
+    readonly serviceRole?: iam.IRole;
+    /**
+     * Whether or not this ComputeEnvironment can accept jobs from a Queue.
+     * Enabled ComputeEnvironments can accept jobs from a Queue and
+     * can scale instances up or down.
+     * Disabled ComputeEnvironments cannot accept jobs from a Queue or
+     * scale instances up or down.
+     *
+     * If you change a ComputeEnvironment from enabled to disabled while it is executing jobs,
+     * Jobs in the `STARTED` or `RUNNING` states will not
+     * be interrupted. As jobs complete, the ComputeEnvironment will scale instances down to `minvCpus`.
+     *
+     * To ensure you aren't billed for unused capacity, set `minvCpus` to `0`.
+     */
+    readonly enabled: boolean;
+}
+/**
+ * Props common to all ComputeEnvironments
+ */
+export interface ComputeEnvironmentProps {
+    /**
+     * The name of the ComputeEnvironment
+     *
+     * @default - generated by CloudFormation
+     */
+    readonly computeEnvironmentName?: string;
+    /**
+     * The role Batch uses to perform actions on your behalf
+     * in your account, such as provision instances to run your jobs
+     *
+     * @default - a serviceRole will be created for managed CEs, none for unmanaged CEs
+     */
+    readonly serviceRole?: iam.IRole;
+    /**
+     * Whether or not this ComputeEnvironment can accept jobs from a Queue.
+     * Enabled ComputeEnvironments can accept jobs from a Queue and
+     * can scale instances up or down.
+     * Disabled ComputeEnvironments cannot accept jobs from a Queue or
+     * scale instances up or down.
+     *
+     * If you change a ComputeEnvironment from enabled to disabled while it is executing jobs,
+     * Jobs in the `STARTED` or `RUNNING` states will not
+     * be interrupted. As jobs complete, the ComputeEnvironment will scale instances down to `minvCpus`.
+     *
+     * To ensure you aren't billed for unused capacity, set `minvCpus` to `0`.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+}
+/**
+ * Abstract base class for ComputeEnvironments
+ *
+ * @internal
+ */
+export declare abstract class ComputeEnvironmentBase extends Resource implements IComputeEnvironment {
+    abstract readonly computeEnvironmentName: string;
+    readonly serviceRole?: iam.IRole | undefined;
+    readonly enabled: boolean;
+    abstract readonly computeEnvironmentArn: string;
+    get computeEnvironmentRef(): ComputeEnvironmentReference;
+    constructor(scope: Construct, id: string, props?: ComputeEnvironmentProps);
+}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/compute-environment-base.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ComputeEnvironmentBase=void 0;var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp};class ComputeEnvironmentBase extends core_1().Resource{serviceRole;enabled;get computeEnvironmentRef(){return{computeEnvironmentArn:this.computeEnvironmentArn}}constructor(scope,id,props){super(scope,id,{physicalName:props?.computeEnvironmentName}),this.serviceRole=props?.serviceRole,this.enabled=props?.enabled??!0}}exports.ComputeEnvironmentBase=ComputeEnvironmentBase;

cdk/node_modules/aws-cdk-lib/aws-batch/lib/ecs-container-definition.d.ts

@@ -0,0 +1,803 @@
+import type { IConstruct } from 'constructs';
+import { Construct } from 'constructs';
+import type { CfnJobDefinition } from './batch.generated';
+import type { LinuxParameters } from './linux-parameters';
+import type * as ecs from '../../aws-ecs';
+import type { IFileSystem } from '../../aws-efs';
+import * as iam from '../../aws-iam';
+import type * as secretsmanager from '../../aws-secretsmanager';
+import type * as ssm from '../../aws-ssm';
+import type { Size } from '../../core';
+import type { IFileSystemRef } from '../../interfaces/generated/aws-efs-interfaces.generated';
+/**
+ * Specify the secret's version id or version stage
+ */
+export interface SecretVersionInfo {
+    /**
+     * version id of the secret
+     *
+     * @default - use default version id
+     */
+    readonly versionId?: string;
+    /**
+     * version stage of the secret
+     *
+     * @default - use default version stage
+     */
+    readonly versionStage?: string;
+}
+/**
+ * A secret environment variable.
+ */
+export declare abstract class Secret {
+    /**
+     * Creates an environment variable value from a parameter stored in AWS
+     * Systems Manager Parameter Store.
+     */
+    static fromSsmParameter(parameter: ssm.IParameter): Secret;
+    /**
+     * Creates a environment variable value from a secret stored in AWS Secrets
+     * Manager.
+     *
+     * @param secret the secret stored in AWS Secrets Manager
+     * @param field the name of the field with the value that you want to set as
+     * the environment variable value. Only values in JSON format are supported.
+     * If you do not specify a JSON field, then the full content of the secret is
+     * used.
+     */
+    static fromSecretsManager(secret: secretsmanager.ISecret, field?: string): Secret;
+    /**
+     * Creates a environment variable value from a secret stored in AWS Secrets
+     * Manager.
+     *
+     * @param secret the secret stored in AWS Secrets Manager
+     * @param versionInfo the version information to reference the secret
+     * @param field the name of the field with the value that you want to set as
+     * the environment variable value. Only values in JSON format are supported.
+     * If you do not specify a JSON field, then the full content of the secret is
+     * used.
+     */
+    static fromSecretsManagerVersion(secret: secretsmanager.ISecret, versionInfo: SecretVersionInfo, field?: string): Secret;
+    /**
+     * The ARN of the secret
+     */
+    abstract readonly arn: string;
+    /**
+     * Whether this secret uses a specific JSON field
+     */
+    abstract readonly hasField?: boolean;
+    /**
+     * Grants reading the secret to a principal
+     * [disable-awslint:no-grants]
+     */
+    abstract grantRead(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * Options to configure an EcsVolume
+ */
+export interface EcsVolumeOptions {
+    /**
+     * the name of this volume
+     */
+    readonly name: string;
+    /**
+     * the path on the container where this volume is mounted
+     */
+    readonly containerPath: string;
+    /**
+     * if set, the container will have readonly access to the volume
+     *
+     * @default false
+     */
+    readonly readonly?: boolean;
+}
+/**
+ * Represents a Volume that can be mounted to a container that uses ECS
+ */
+export declare abstract class EcsVolume {
+    /**
+     * Creates a Volume that uses an AWS Elastic File System (EFS); this volume can grow and shrink as needed
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html
+     */
+    static efs(options: EfsVolumeOptions): EfsVolume;
+    /**
+     * Creates a Host volume. This volume will persist on the host at the specified `hostPath`.
+     * If the `hostPath` is not specified, Docker will choose the host path. In this case,
+     * the data may not persist after the containers that use it stop running.
+     */
+    static host(options: HostVolumeOptions): HostVolume;
+    /**
+     * The name of this volume
+     */
+    readonly name: string;
+    /**
+     * The path on the container that this volume will be mounted to
+     */
+    readonly containerPath: string;
+    /**
+     * Whether or not the container has readonly access to this volume
+     *
+     * @default false
+     */
+    readonly readonly?: boolean;
+    constructor(options: EcsVolumeOptions);
+}
+/**
+ * Options for configuring an EfsVolume
+ */
+export interface EfsVolumeOptions extends EcsVolumeOptions {
+    /**
+     * The EFS File System that supports this volume
+     */
+    readonly fileSystem: IFileSystemRef;
+    /**
+     * The directory within the Amazon EFS file system to mount as the root directory inside the host.
+     * If this parameter is omitted, the root of the Amazon EFS volume is used instead.
+     * Specifying `/` has the same effect as omitting this parameter.
+     * The maximum length is 4,096 characters.
+     *
+     * @default - root of the EFS File System
+     */
+    readonly rootDirectory?: string;
+    /**
+     * Enables encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html
+     *
+     * @default false
+     */
+    readonly enableTransitEncryption?: boolean;
+    /**
+     * The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server.
+     * The value must be between 0 and 65,535.
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html
+     *
+     * @default - chosen by the EFS Mount Helper
+     */
+    readonly transitEncryptionPort?: number;
+    /**
+     * The Amazon EFS access point ID to use.
+     * If an access point is specified, `rootDirectory` must either be omitted or set to `/`
+     * which enforces the path set on the EFS access point.
+     * If an access point is used, `enableTransitEncryption` must be `true`.
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html
+     *
+     * @default - no accessPointId
+     */
+    readonly accessPointId?: string;
+    /**
+     * Whether or not to use the AWS Batch job IAM role defined in a job definition when mounting the Amazon EFS file system.
+     * If specified, `enableTransitEncryption` must be `true`.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html#efs-volume-accesspoints
+     *
+     * @default false
+     */
+    readonly useJobRole?: boolean;
+}
+/**
+ * A Volume that uses an AWS Elastic File System (EFS); this volume can grow and shrink as needed
+ */
+export declare class EfsVolume extends EcsVolume {
+    /**
+     * Returns true if x is an EfsVolume, false otherwise
+     */
+    static isEfsVolume(x: any): x is EfsVolume;
+    private readonly _fileSystem;
+    /**
+     * The EFS File System that supports this volume
+     */
+    get fileSystem(): IFileSystem;
+    /**
+     * @internal
+     */
+    get _fileSystemRef(): IFileSystemRef;
+    /**
+     * The directory within the Amazon EFS file system to mount as the root directory inside the host.
+     * If this parameter is omitted, the root of the Amazon EFS volume is used instead.
+     * Specifying `/` has the same effect as omitting this parameter.
+     * The maximum length is 4,096 characters.
+     *
+     * @default - root of the EFS File System
+     */
+    readonly rootDirectory?: string;
+    /**
+     * Enables encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html
+     *
+     * @default false
+     */
+    readonly enableTransitEncryption?: boolean;
+    /**
+     * The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server.
+     * The value must be between 0 and 65,535.
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html
+     *
+     * @default - chosen by the EFS Mount Helper
+     */
+    readonly transitEncryptionPort?: number;
+    /**
+     * The Amazon EFS access point ID to use.
+     * If an access point is specified, `rootDirectory` must either be omitted or set to `/`
+     * which enforces the path set on the EFS access point.
+     * If an access point is used, `enableTransitEncryption` must be `true`.
+     *
+     * @see https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html
+     *
+     * @default - no accessPointId
+     */
+    readonly accessPointId?: string;
+    /**
+     * Whether or not to use the AWS Batch job IAM role defined in a job definition when mounting the Amazon EFS file system.
+     * If specified, `enableTransitEncryption` must be `true`.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/efs-volumes.html#efs-volume-accesspoints
+     *
+     * @default false
+     */
+    readonly useJobRole?: boolean;
+    constructor(options: EfsVolumeOptions);
+}
+/**
+ * Options for configuring an ECS HostVolume
+ */
+export interface HostVolumeOptions extends EcsVolumeOptions {
+    /**
+     * The path on the host machine this container will have access to
+     *
+     * @default - Docker will choose the host path.
+     * The data may not persist after the containers that use it stop running.
+     */
+    readonly hostPath?: string;
+}
+/**
+ * Creates a Host volume. This volume will persist on the host at the specified `hostPath`.
+ * If the `hostPath` is not specified, Docker will choose the host path. In this case,
+ * the data may not persist after the containers that use it stop running.
+ */
+export declare class HostVolume extends EcsVolume {
+    /**
+     * returns `true` if `x` is a `HostVolume`, `false` otherwise
+     */
+    static isHostVolume(x: any): x is HostVolume;
+    /**
+     * The path on the host machine this container will have access to
+     */
+    readonly hostPath?: string;
+    constructor(options: HostVolumeOptions);
+}
+/**
+ * A container that can be run with ECS orchestration
+ */
+export interface IEcsContainerDefinition extends IConstruct {
+    /**
+     * The image that this container will run
+     */
+    readonly image: ecs.ContainerImage;
+    /**
+     * The number of vCPUs reserved for the container.
+     * Each vCPU is equivalent to 1,024 CPU shares.
+     * For containers running on EC2 resources, you must specify at least one vCPU.
+     */
+    readonly cpu: number;
+    /**
+     * The memory hard limit present to the container.
+     * If your container attempts to exceed the memory specified, the container is terminated.
+     * You must specify at least 4 MiB of memory for a job.
+     */
+    readonly memory: Size;
+    /**
+     * The command that's passed to the container
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#cmd
+     */
+    readonly command?: string[];
+    /**
+     * The environment variables to pass to a container.
+     * Cannot start with `AWS_BATCH`.
+     * We don't recommend using plaintext environment variables for sensitive information, such as credential data.
+     *
+     * @default - no environment variables
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
+     */
+    readonly executionRole: iam.IRole;
+    /**
+     * The role that the container can assume.
+     *
+     * @default - no jobRole
+     *
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
+     */
+    readonly jobRole?: iam.IRole;
+    /**
+     * Linux-specific modifications that are applied to the container, such as details for device mappings.
+     *
+     * @default none
+     */
+    readonly linuxParameters?: LinuxParameters;
+    /**
+     * The configuration of the log driver
+     */
+    readonly logDriverConfig?: ecs.LogDriverConfig;
+    /**
+     * Gives the container readonly access to its root filesystem.
+     *
+     * @default false
+     */
+    readonly readonlyRootFilesystem?: boolean;
+    /**
+     * A map from environment variable names to the secrets for the container. Allows your job definitions
+     * to reference the secret by the environment variable name defined in this property.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
+     *
+     * @default - no secrets
+     */
+    readonly secrets?: {
+        [envVarName: string]: Secret;
+    };
+    /**
+     * The user name to use inside the container
+     *
+     * @default - no user
+     */
+    readonly user?: string;
+    /**
+     * The volumes to mount to this container. Automatically added to the job definition.
+     *
+     * @default - no volumes
+     */
+    readonly volumes: EcsVolume[];
+    /**
+     * Whether to enable ecs exec for this container.
+     *
+     * @default undefined - AWS Batch default is false
+     */
+    readonly enableExecuteCommand?: boolean;
+    /**
+     * Renders this container to CloudFormation
+     *
+     * @internal
+     */
+    _renderContainerDefinition(): CfnJobDefinition.ContainerPropertiesProperty;
+    /**
+     * Add a Volume to this container
+     */
+    addVolume(volume: EcsVolume): void;
+}
+/**
+ * Props to configure an EcsContainerDefinition
+ */
+export interface EcsContainerDefinitionProps {
+    /**
+     * The image that this container will run
+     */
+    readonly image: ecs.ContainerImage;
+    /**
+     * The number of vCPUs reserved for the container.
+     * Each vCPU is equivalent to 1,024 CPU shares.
+     * For containers running on EC2 resources, you must specify at least one vCPU.
+     */
+    readonly cpu: number;
+    /**
+     * The memory hard limit present to the container.
+     * If your container attempts to exceed the memory specified, the container is terminated.
+     * You must specify at least 4 MiB of memory for a job.
+     */
+    readonly memory: Size;
+    /**
+     * The command that's passed to the container
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#cmd
+     *
+     * @default - no command
+     */
+    readonly command?: string[];
+    /**
+     * The environment variables to pass to a container.
+     * Cannot start with `AWS_BATCH`.
+     * We don't recommend using plaintext environment variables for sensitive information, such as credential data.
+     *
+     * @default - no environment variables
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html
+     *
+     * @default - a Role will be created
+     */
+    readonly executionRole?: iam.IRole;
+    /**
+     * The role that the container can assume.
+     *
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html
+     *
+     * @default - no job role
+     */
+    readonly jobRole?: iam.IRole;
+    /**
+     * Linux-specific modifications that are applied to the container, such as details for device mappings.
+     *
+     * @default none
+     */
+    readonly linuxParameters?: LinuxParameters;
+    /**
+     * The loging configuration for this Job
+     *
+     * @default - the log configuration of the Docker daemon
+     */
+    readonly logging?: ecs.LogDriver;
+    /**
+     * Gives the container readonly access to its root filesystem.
+     *
+     * @default false
+     */
+    readonly readonlyRootFilesystem?: boolean;
+    /**
+     * A map from environment variable names to the secrets for the container. Allows your job definitions
+     * to reference the secret by the environment variable name defined in this property.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html
+     *
+     * @default - no secrets
+     */
+    readonly secrets?: {
+        [envVarName: string]: Secret;
+    };
+    /**
+     * The user name to use inside the container
+     *
+     * @default - no user
+     */
+    readonly user?: string;
+    /**
+     * The volumes to mount to this container. Automatically added to the job definition.
+     *
+     * @default - no volumes
+     */
+    readonly volumes?: EcsVolume[];
+    /**
+     * Determines whether execute command functionality is turned on for this task.
+     *
+     * If true, execute command functionality is turned on all the containers in the task.
+     *
+     * This allows you to use ECS Exec to access containers interactively.
+     * When enabled, a job role with required SSM permissions will be created automatically if no job role is provided.
+     * If a job role is alreadyprovided, the required permissions will be added to it.
+     *
+     * @default undefined - AWS Batch default is false
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html
+     */
+    readonly enableExecuteCommand?: boolean;
+}
+/**
+ * Abstract base class for ECS Containers
+ */
+declare abstract class EcsContainerDefinitionBase extends Construct implements IEcsContainerDefinition {
+    readonly image: ecs.ContainerImage;
+    readonly cpu: number;
+    readonly memory: Size;
+    readonly command?: string[];
+    readonly environment?: {
+        [key: string]: string;
+    };
+    readonly executionRole: iam.IRole;
+    readonly jobRole?: iam.IRole;
+    readonly linuxParameters?: LinuxParameters;
+    readonly logDriverConfig?: ecs.LogDriverConfig;
+    readonly readonlyRootFilesystem?: boolean;
+    readonly secrets?: {
+        [envVarName: string]: Secret;
+    };
+    readonly user?: string;
+    readonly volumes: EcsVolume[];
+    readonly enableExecuteCommand?: boolean;
+    private readonly imageConfig;
+    constructor(scope: Construct, id: string, props: EcsContainerDefinitionProps);
+    /**
+     * @internal
+     */
+    _renderContainerDefinition(): CfnJobDefinition.ContainerPropertiesProperty;
+    addVolume(volume: EcsVolume): void;
+    /**
+     * @internal
+     */
+    protected _renderResourceRequirements(): {
+        type: string;
+        value: string;
+    }[];
+    /**
+     * Handles job role setup for ECS Exec functionality
+     * @internal
+     */
+    private handleJobRoleForEcsExec;
+    /**
+     * Creates a new job role with ECS Exec permissions
+     * @internal
+     */
+    private createJobRoleWithEcsExecPermissions;
+    /**
+     * Adds ECS Exec required permissions to a role
+     * @internal
+     */
+    private addEcsExecPermissions;
+}
+/**
+ * Sets limits for a resource with `ulimit` on linux systems.
+ * Used by the Docker daemon.
+ */
+export interface Ulimit {
+    /**
+     * The hard limit for this resource. The container will
+     * be terminated if it exceeds this limit.
+     */
+    readonly hardLimit: number;
+    /**
+     * The resource to limit
+     */
+    readonly name: UlimitName;
+    /**
+     * The reservation for this resource. The container will
+     * not be terminated if it exceeds this limit.
+     */
+    readonly softLimit: number;
+}
+/**
+ * The resources to be limited
+ */
+export declare enum UlimitName {
+    /**
+     * max core dump file size
+     */
+    CORE = "core",
+    /**
+     * max cpu time (seconds) for a process
+     */
+    CPU = "cpu",
+    /**
+     * max data segment size
+     */
+    DATA = "data",
+    /**
+     * max file size
+     */
+    FSIZE = "fsize",
+    /**
+     * max number of file locks
+     */
+    LOCKS = "locks",
+    /**
+     * max locked memory
+     */
+    MEMLOCK = "memlock",
+    /**
+     * max POSIX message queue size
+     */
+    MSGQUEUE = "msgqueue",
+    /**
+     * max nice value for any process this user is running
+     */
+    NICE = "nice",
+    /**
+     * maximum number of open file descriptors
+     */
+    NOFILE = "nofile",
+    /**
+     * maximum number of processes
+     */
+    NPROC = "nproc",
+    /**
+     * size of the process' resident set (in pages)
+     */
+    RSS = "rss",
+    /**
+     * max realtime priority
+     */
+    RTPRIO = "rtprio",
+    /**
+     * timeout for realtime tasks
+     */
+    RTTIME = "rttime",
+    /**
+     * max number of pending signals
+     */
+    SIGPENDING = "sigpending",
+    /**
+     * max stack size (in bytes)
+     */
+    STACK = "stack"
+}
+/**
+ * A container orchestrated by ECS that uses EC2 resources
+ */
+export interface IEcsEc2ContainerDefinition extends IEcsContainerDefinition {
+    /**
+     * When this parameter is true, the container is given elevated permissions on the host container instance (similar to the root user).
+     *
+     * @default false
+     */
+    readonly privileged?: boolean;
+    /**
+     * Limits to set for the user this docker container will run as
+     */
+    readonly ulimits: Ulimit[];
+    /**
+     * The number of physical GPUs to reserve for the container.
+     * Make sure that the number of GPUs reserved for all containers in a job doesn't exceed
+     * the number of available GPUs on the compute resource that the job is launched on.
+     *
+     * @default - no gpus
+     */
+    readonly gpu?: number;
+    /**
+     * Add a ulimit to this container
+     */
+    addUlimit(ulimit: Ulimit): void;
+}
+/**
+ * Props to configure an EcsEc2ContainerDefinition
+ */
+export interface EcsEc2ContainerDefinitionProps extends EcsContainerDefinitionProps {
+    /**
+     * When this parameter is true, the container is given elevated permissions on the host container instance (similar to the root user).
+     *
+     * @default false
+     */
+    readonly privileged?: boolean;
+    /**
+     * Limits to set for the user this docker container will run as
+     *
+     * @default - no ulimits
+     */
+    readonly ulimits?: Ulimit[];
+    /**
+     * The number of physical GPUs to reserve for the container.
+     * Make sure that the number of GPUs reserved for all containers in a job doesn't exceed
+     * the number of available GPUs on the compute resource that the job is launched on.
+     *
+     * @default - no gpus
+     */
+    readonly gpu?: number;
+}
+/**
+ * A container orchestrated by ECS that uses EC2 resources
+ */
+export declare class EcsEc2ContainerDefinition extends EcsContainerDefinitionBase implements IEcsEc2ContainerDefinition {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly privileged?: boolean;
+    readonly ulimits: Ulimit[];
+    readonly gpu?: number;
+    constructor(scope: Construct, id: string, props: EcsEc2ContainerDefinitionProps);
+    /**
+     * @internal
+     */
+    _renderContainerDefinition(): CfnJobDefinition.ContainerPropertiesProperty;
+    /**
+     * Add a ulimit to this container
+     */
+    addUlimit(ulimit: Ulimit): void;
+    /**
+     * @internal
+     */
+    protected _renderResourceRequirements(): {
+        type: string;
+        value: string;
+    }[];
+}
+/**
+ * A container orchestrated by ECS that uses Fargate resources and is orchestrated by ECS
+ */
+export interface IEcsFargateContainerDefinition extends IEcsContainerDefinition {
+    /**
+     * Indicates whether the job has a public IP address.
+     * For a job that's running on Fargate resources in a private subnet to send outbound traffic to the internet
+     * (for example, to pull container images), the private subnet requires a NAT gateway be attached to route requests to the internet.
+     *
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html
+     *
+     * @default false
+     */
+    readonly assignPublicIp?: boolean;
+    /**
+     * Which version of Fargate to use when running this container
+     *
+     * @default LATEST
+     */
+    readonly fargatePlatformVersion?: ecs.FargatePlatformVersion;
+    /**
+     * The size for ephemeral storage.
+     *
+     * @default - 20 GiB
+     */
+    readonly ephemeralStorageSize?: Size;
+    /**
+     * The vCPU architecture of Fargate Runtime.
+     *
+     * @default - X86_64
+     */
+    readonly fargateCpuArchitecture?: ecs.CpuArchitecture;
+    /**
+     * The operating system for the compute environment.
+     *
+     * @default - LINUX
+     */
+    readonly fargateOperatingSystemFamily?: ecs.OperatingSystemFamily;
+}
+/**
+ * Props to configure an EcsFargateContainerDefinition
+ */
+export interface EcsFargateContainerDefinitionProps extends EcsContainerDefinitionProps {
+    /**
+     * Indicates whether the job has a public IP address.
+     * For a job that's running on Fargate resources in a private subnet to send outbound traffic to the internet
+     * (for example, to pull container images), the private subnet requires a NAT gateway be attached to route requests to the internet.
+     *
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html
+     *
+     * @default false
+     */
+    readonly assignPublicIp?: boolean;
+    /**
+     * Which version of Fargate to use when running this container
+     *
+     * @default LATEST
+     */
+    readonly fargatePlatformVersion?: ecs.FargatePlatformVersion;
+    /**
+     * The size for ephemeral storage.
+     *
+     * @default - 20 GiB
+     */
+    readonly ephemeralStorageSize?: Size;
+    /**
+     * The vCPU architecture of Fargate Runtime.
+     *
+     * @default - X86_64
+     */
+    readonly fargateCpuArchitecture?: ecs.CpuArchitecture;
+    /**
+     * The operating system for the compute environment.
+     *
+     * @default - LINUX
+     */
+    readonly fargateOperatingSystemFamily?: ecs.OperatingSystemFamily;
+}
+/**
+ * A container orchestrated by ECS that uses Fargate resources
+ */
+export declare class EcsFargateContainerDefinition extends EcsContainerDefinitionBase implements IEcsFargateContainerDefinition {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly fargatePlatformVersion?: ecs.FargatePlatformVersion;
+    readonly assignPublicIp?: boolean;
+    readonly ephemeralStorageSize?: Size;
+    readonly fargateCpuArchitecture?: ecs.CpuArchitecture;
+    readonly fargateOperatingSystemFamily?: ecs.OperatingSystemFamily;
+    constructor(scope: Construct, id: string, props: EcsFargateContainerDefinitionProps);
+    /**
+     * @internal
+     */
+    _renderContainerDefinition(): CfnJobDefinition.ContainerPropertiesProperty;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-batch/lib/ecs-job-definition.d.ts

@@ -0,0 +1,73 @@
+import type { Construct } from 'constructs';
+import type { IEcsContainerDefinition } from './ecs-container-definition';
+import type { IJobDefinition, JobDefinitionProps } from './job-definition-base';
+import { JobDefinitionBase } from './job-definition-base';
+import * as iam from '../../aws-iam';
+import type { IJobQueueRef } from '../../interfaces/generated/aws-batch-interfaces.generated';
+/**
+ * A JobDefinition that uses ECS orchestration
+ */
+interface IEcsJobDefinition extends IJobDefinition {
+    /**
+     * The container that this job will run
+     */
+    readonly container: IEcsContainerDefinition;
+    /**
+     * Whether to propagate tags from the JobDefinition
+     * to the ECS task that Batch spawns
+     *
+     * @default false
+     */
+    readonly propagateTags?: boolean;
+}
+/**
+ * @internal
+ */
+export declare enum Compatibility {
+    EC2 = "EC2",
+    FARGATE = "FARGATE"
+}
+/**
+ * Props for EcsJobDefinition
+ */
+export interface EcsJobDefinitionProps extends JobDefinitionProps {
+    /**
+     * The container that this job will run
+     */
+    readonly container: IEcsContainerDefinition;
+    /**
+     * Whether to propagate tags from the JobDefinition
+     * to the ECS task that Batch spawns
+     *
+     * @default false
+     */
+    readonly propagateTags?: boolean;
+}
+/**
+ * A JobDefinition that uses ECS orchestration
+ *
+ * @resource AWS::Batch::JobDefinition
+ */
+export declare class EcsJobDefinition extends JobDefinitionBase implements IEcsJobDefinition {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import a JobDefinition by its arn.
+     */
+    static fromJobDefinitionArn(scope: Construct, id: string, jobDefinitionArn: string): IJobDefinition;
+    private static getJobDefinitionName;
+    readonly container: IEcsContainerDefinition;
+    readonly propagateTags?: boolean;
+    private readonly resource;
+    get jobDefinitionArn(): string;
+    get jobDefinitionName(): string;
+    constructor(scope: Construct, id: string, props: EcsJobDefinitionProps);
+    /**
+     * Grants the `batch:submitJob` permission to the identity on both this job definition and the `queue`
+     *
+     * [disable-awslint:no-grants]
+     */
+    grantSubmitJob(identity: iam.IGrantable, queue: IJobQueueRef): void;
+    private renderPlatformCapabilities;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-batch/lib/eks-container-definition.d.ts

@@ -0,0 +1,733 @@
+import type { IConstruct } from 'constructs';
+import { Construct } from 'constructs';
+import type { CfnJobDefinition } from './batch.generated';
+import type * as ecs from '../../aws-ecs';
+import type { Size } from '../../core';
+/**
+ * A container that can be run with EKS orchestration on EC2 resources
+ */
+export interface IEksContainerDefinition extends IConstruct {
+    /**
+     * The image that this container will run
+     */
+    readonly image: ecs.ContainerImage;
+    /**
+     * An array of arguments to the entrypoint.
+     * If this isn't specified, the CMD of the container image is used.
+     * This corresponds to the args member in the Entrypoint portion of the Pod in Kubernetes.
+     * Environment variable references are expanded using the container's environment.
+     * If the referenced environment variable doesn't exist, the reference in the command isn't changed.
+     * For example, if the reference is to "$(NAME1)" and the NAME1 environment variable doesn't exist,
+     * the command string will remain "$(NAME1)." $$ is replaced with $, and the resulting string isn't expanded.
+     * or example, $$(VAR_NAME) is passed as $(VAR_NAME) whether or not the VAR_NAME environment variable exists.
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#cmd
+     * @see https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
+     */
+    readonly args?: string[];
+    /**
+     * The entrypoint for the container. This isn't run within a shell.
+     * If this isn't specified, the `ENTRYPOINT` of the container image is used.
+     * Environment variable references are expanded using the container's environment.
+     * If the referenced environment variable doesn't exist, the reference in the command isn't changed.
+     * For example, if the reference is to `"$(NAME1)"` and the `NAME1` environment variable doesn't exist,
+     * the command string will remain `"$(NAME1)."` `$$` is replaced with `$` and the resulting string isn't expanded.
+     * For example, `$$(VAR_NAME)` will be passed as `$(VAR_NAME)` whether or not the `VAR_NAME` environment variable exists.
+     *
+     * The entrypoint can't be updated.
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#entrypoint
+     * @see https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
+     * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
+     */
+    readonly command?: string[];
+    /**
+     * The environment variables to pass to this container.
+     *
+     * *Note*: Environment variables cannot start with "AWS_BATCH".
+     * This naming convention is reserved for variables that AWS Batch sets.
+     */
+    readonly env?: {
+        [key: string]: string;
+    };
+    /**
+     * The image pull policy for this container
+     *
+     * @see https://kubernetes.io/docs/concepts/containers/images/#updating-images
+     *
+     * @default - `ALWAYS` if the `:latest` tag is specified, `IF_NOT_PRESENT` otherwise
+     */
+    readonly imagePullPolicy?: ImagePullPolicy;
+    /**
+     * The name of this container
+     *
+     * @default: `'Default'`
+     */
+    readonly name?: string;
+    /**
+     * The amount (in MiB) of memory to present to the container.
+     * If your container attempts to exceed the allocated memory, it will be terminated.
+     *
+     * Must be larger that 4 MiB
+     *
+     * At least one of `memoryLimit` and `memoryReservation` is required
+     *
+     * *Note*: To maximize your resource utilization, provide your jobs with as much memory as possible
+     * for the specific instance type that you are using.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
+     *
+     * @default - No memory limit
+     */
+    readonly memoryLimit?: Size;
+    /**
+     * The soft limit (in MiB) of memory to reserve for the container.
+     * Your container will be given at least this much memory, but may consume more.
+     *
+     * Must be larger that 4 MiB
+     *
+     * When system memory is under heavy contention, Docker attempts to keep the
+     * container memory to this soft limit. However, your container can consume more
+     * memory when it needs to, up to either the hard limit specified with the memory
+     * parameter (if applicable), or all of the available memory on the container
+     * instance, whichever comes first.
+     *
+     * At least one of `memoryLimit` and `memoryReservation` is required.
+     * If both are specified, then `memoryLimit` must be equal to `memoryReservation`
+     *
+     * *Note*: To maximize your resource utilization, provide your jobs with as much memory as possible
+     * for the specific instance type that you are using.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
+     *
+     * @default - No memory reserved
+     */
+    readonly memoryReservation?: Size;
+    /**
+     * The hard limit of CPUs to present to this container.
+     * Must be an even multiple of 0.25
+     *
+     * If your container attempts to exceed this limit, it will be terminated.
+     *
+     * At least one of `cpuReservation` and `cpuLimit` is required.
+     * If both are specified, then `cpuLimit` must be at least as large as `cpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No CPU limit
+     */
+    readonly cpuLimit?: number;
+    /**
+     * The soft limit of CPUs to reserve for the container
+     * Must be an even multiple of 0.25
+     *
+     * The container will given at least this many CPUs, but may consume more.
+     *
+     * At least one of `cpuReservation` and `cpuLimit` is required.
+     * If both are specified, then `cpuLimit` must be at least as large as `cpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No CPUs reserved
+     */
+    readonly cpuReservation?: number;
+    /**
+     * The hard limit of GPUs to present to this container.
+     *
+     * If your container attempts to exceed this limit, it will be terminated.
+     *
+     * If both `gpuReservation` and `gpuLimit` are specified, then `gpuLimit` must be equal to `gpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No GPU limit
+     */
+    readonly gpuLimit?: number;
+    /**
+     * The soft limit of CPUs to reserve for the container
+     * Must be an even multiple of 0.25
+     *
+     * The container will given at least this many CPUs, but may consume more.
+     *
+     * If both `gpuReservation` and `gpuLimit` are specified, then `gpuLimit` must be equal to `gpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No GPUs reserved
+     */
+    readonly gpuReservation?: number;
+    /**
+     * If specified, gives this container elevated permissions on the host container instance.
+     * The level of permissions are similar to the root user permissions.
+     *
+     * This parameter maps to `privileged` policy in the Privileged pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems
+     *
+     * @default false
+     */
+    readonly privileged?: boolean;
+    /**
+     * If specified, gives this container readonly access to its root file system.
+     *
+     * This parameter maps to `ReadOnlyRootFilesystem` policy in the Volumes and file systems pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems
+     *
+     * @default false
+     */
+    readonly readonlyRootFilesystem?: boolean;
+    /**
+     * If specified, the container is run as the specified group ID (`gid`).
+     * If this parameter isn't specified, the default is the group that's specified in the image metadata.
+     * This parameter maps to `RunAsGroup` and `MustRunAs` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default none
+     */
+    readonly runAsGroup?: number;
+    /**
+     * If specified, the container is run as a user with a `uid` other than 0. Otherwise, no such rule is enforced.
+     * This parameter maps to `RunAsUser` and `MustRunAsNonRoot` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default - the container is *not* required to run as a non-root user
+     */
+    readonly runAsRoot?: boolean;
+    /**
+     * If specified, this container is run as the specified user ID (`uid`).
+     * This parameter maps to `RunAsUser` and `MustRunAs` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default - the user that is specified in the image metadata.
+     */
+    readonly runAsUser?: number;
+    /**
+     * The Volumes to mount to this container.
+     * Automatically added to the Pod.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/
+     */
+    readonly volumes: EksVolume[];
+    /**
+     * Mount a Volume to this container. Automatically added to the Pod.
+     */
+    addVolume(volume: EksVolume): void;
+}
+/**
+ * Determines when the image is pulled from the registry to launch a container
+ */
+export declare enum ImagePullPolicy {
+    /**
+     * Every time the kubelet launches a container,
+     * the kubelet queries the container image registry to resolve the name to an image digest.
+     * If the kubelet has a container image with that exact digest cached locally,
+     * the kubelet uses its cached image; otherwise, the kubelet pulls the image with the resolved digest,
+     * and uses that image to launch the container.
+     *
+     * @see https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier
+     */
+    ALWAYS = "Always",
+    /**
+     * The image is pulled only if it is not already present locally
+     */
+    IF_NOT_PRESENT = "IfNotPresent",
+    /**
+     * The kubelet does not try fetching the image.
+     * If the image is somehow already present locally,
+     * the kubelet attempts to start the container; otherwise, startup fails.
+     * See pre-pulled images for more details.
+     *
+     * @see https://kubernetes.io/docs/concepts/containers/images/#pre-pulled-images
+     */
+    NEVER = "Never"
+}
+/**
+ * Props to configure an EksContainerDefinition
+ */
+export interface EksContainerDefinitionProps {
+    /**
+     * The image that this container will run
+     */
+    readonly image: ecs.ContainerImage;
+    /**
+     * An array of arguments to the entrypoint.
+     * If this isn't specified, the CMD of the container image is used.
+     * This corresponds to the args member in the Entrypoint portion of the Pod in Kubernetes.
+     * Environment variable references are expanded using the container's environment.
+     * If the referenced environment variable doesn't exist, the reference in the command isn't changed.
+     * For example, if the reference is to "$(NAME1)" and the NAME1 environment variable doesn't exist,
+     * the command string will remain "$(NAME1)." $$ is replaced with $, and the resulting string isn't expanded.
+     * or example, $$(VAR_NAME) is passed as $(VAR_NAME) whether or not the VAR_NAME environment variable exists.
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#cmd
+     * @see https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
+     *
+     * @default - no args
+     */
+    readonly args?: string[];
+    /**
+     * The entrypoint for the container. This isn't run within a shell.
+     * If this isn't specified, the `ENTRYPOINT` of the container image is used.
+     * Environment variable references are expanded using the container's environment.
+     * If the referenced environment variable doesn't exist, the reference in the command isn't changed.
+     * For example, if the reference is to `"$(NAME1)"` and the `NAME1` environment variable doesn't exist,
+     * the command string will remain `"$(NAME1)."` `$$` is replaced with `$` and the resulting string isn't expanded.
+     * For example, `$$(VAR_NAME)` will be passed as `$(VAR_NAME)` whether or not the `VAR_NAME` environment variable exists.
+     *
+     * The entrypoint can't be updated.
+     *
+     * @see https://docs.docker.com/engine/reference/builder/#entrypoint
+     * @see https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/
+     * @see https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint
+     *
+     * @default - no command
+     */
+    readonly command?: string[];
+    /**
+     * The environment variables to pass to this container.
+     *
+     * *Note*: Environment variables cannot start with "AWS_BATCH".
+     * This naming convention is reserved for variables that AWS Batch sets.
+     *
+     * @default - no environment variables
+     */
+    readonly env?: {
+        [key: string]: string;
+    };
+    /**
+     * The image pull policy for this container
+     *
+     * @see https://kubernetes.io/docs/concepts/containers/images/#updating-images
+     *
+     * @default - `ALWAYS` if the `:latest` tag is specified, `IF_NOT_PRESENT` otherwise
+     */
+    readonly imagePullPolicy?: ImagePullPolicy;
+    /**
+     * The name of this container
+     *
+     * @default: `'Default'`
+     */
+    readonly name?: string;
+    /**
+     * The amount (in MiB) of memory to present to the container.
+     * If your container attempts to exceed the allocated memory, it will be terminated.
+     *
+     * Must be larger that 4 MiB
+     *
+     * At least one of `memoryLimit` and `memoryReservation` is required
+     *
+     * *Note*: To maximize your resource utilization, provide your jobs with as much memory as possible
+     * for the specific instance type that you are using.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
+     *
+     * @default - No memory limit
+     */
+    readonly memoryLimit?: Size;
+    /**
+     * The soft limit (in MiB) of memory to reserve for the container.
+     * Your container will be given at least this much memory, but may consume more.
+     *
+     * Must be larger that 4 MiB
+     *
+     * When system memory is under heavy contention, Docker attempts to keep the
+     * container memory to this soft limit. However, your container can consume more
+     * memory when it needs to, up to either the hard limit specified with the memory
+     * parameter (if applicable), or all of the available memory on the container
+     * instance, whichever comes first.
+     *
+     * At least one of `memoryLimit` and `memoryReservation` is required.
+     * If both are specified, then `memoryLimit` must be equal to `memoryReservation`
+     *
+     * *Note*: To maximize your resource utilization, provide your jobs with as much memory as possible
+     * for the specific instance type that you are using.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
+     *
+     * @default - No memory reserved
+     */
+    readonly memoryReservation?: Size;
+    /**
+     * The hard limit of CPUs to present to this container.
+     * Must be an even multiple of 0.25
+     *
+     * If your container attempts to exceed this limit, it will be terminated.
+     *
+     * At least one of `cpuReservation` and `cpuLimit` is required.
+     * If both are specified, then `cpuLimit` must be at least as large as `cpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No CPU limit
+     */
+    readonly cpuLimit?: number;
+    /**
+     * The soft limit of CPUs to reserve for the container
+     * Must be an even multiple of 0.25
+     *
+     * The container will given at least this many CPUs, but may consume more.
+     *
+     * At least one of `cpuReservation` and `cpuLimit` is required.
+     * If both are specified, then `cpuLimit` must be at least as large as `cpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No CPUs reserved
+     */
+    readonly cpuReservation?: number;
+    /**
+     * The hard limit of GPUs to present to this container.
+     *
+     * If your container attempts to exceed this limit, it will be terminated.
+     *
+     * If both `gpuReservation` and `gpuLimit` are specified, then `gpuLimit` must be equal to `gpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No GPU limit
+     */
+    readonly gpuLimit?: number;
+    /**
+     * The soft limit of CPUs to reserve for the container
+     * Must be an even multiple of 0.25
+     *
+     * The container will given at least this many CPUs, but may consume more.
+     *
+     * If both `gpuReservation` and `gpuLimit` are specified, then `gpuLimit` must be equal to `gpuReservation`.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @default - No GPUs reserved
+     */
+    readonly gpuReservation?: number;
+    /**
+     * If specified, gives this container elevated permissions on the host container instance.
+     * The level of permissions are similar to the root user permissions.
+     *
+     * This parameter maps to `privileged` policy in the Privileged pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems
+     *
+     * @default false
+     */
+    readonly privileged?: boolean;
+    /**
+     * If specified, gives this container readonly access to its root file system.
+     *
+     * This parameter maps to `ReadOnlyRootFilesystem` policy in the Volumes and file systems pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems
+     *
+     * @default false
+     */
+    readonly readonlyRootFilesystem?: boolean;
+    /**
+     * If specified, the container is run as the specified group ID (`gid`).
+     * If this parameter isn't specified, the default is the group that's specified in the image metadata.
+     * This parameter maps to `RunAsGroup` and `MustRunAs` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default none
+     */
+    readonly runAsGroup?: number;
+    /**
+     * If specified, the container is run as a user with a `uid` other than 0. Otherwise, no such rule is enforced.
+     * This parameter maps to `RunAsUser` and `MustRunAsNonRoot` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default - the container is *not* required to run as a non-root user
+     */
+    readonly runAsRoot?: boolean;
+    /**
+     * If specified, this container is run as the specified user ID (`uid`).
+     * This parameter maps to `RunAsUser` and `MustRunAs` policy in the Users and groups pod security policies in the Kubernetes documentation.
+     *
+     * *Note*: this is only compatible with Kubernetes < v1.25
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups
+     *
+     * @default - the user that is specified in the image metadata.
+     */
+    readonly runAsUser?: number;
+    /**
+     * The Volumes to mount to this container.
+     * Automatically added to the Pod.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/
+     *
+     * @default - no volumes
+     */
+    readonly volumes?: EksVolume[];
+}
+/**
+ * A container that can be run with EKS orchestration on EC2 resources
+ */
+export declare class EksContainerDefinition extends Construct implements IEksContainerDefinition {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly image: ecs.ContainerImage;
+    readonly args?: string[];
+    readonly command?: string[];
+    readonly env?: {
+        [key: string]: string;
+    };
+    readonly imagePullPolicy?: ImagePullPolicy;
+    readonly name?: string;
+    readonly memoryLimit?: Size;
+    readonly memoryReservation?: Size;
+    readonly cpuLimit?: number;
+    readonly cpuReservation?: number;
+    readonly gpuLimit?: number;
+    readonly gpuReservation?: number;
+    readonly privileged?: boolean;
+    readonly readonlyRootFilesystem?: boolean;
+    readonly runAsGroup?: number;
+    readonly runAsRoot?: boolean;
+    readonly runAsUser?: number;
+    readonly volumes: EksVolume[];
+    private readonly imageConfig;
+    constructor(scope: Construct, id: string, props: EksContainerDefinitionProps);
+    addVolume(volume: EksVolume): void;
+    /**
+     *
+     * @internal
+     */
+    _renderContainerDefinition(): CfnJobDefinition.EksContainerProperty;
+}
+/**
+ * Options to configure an EksVolume
+ */
+export interface EksVolumeOptions {
+    /**
+     * The name of this volume.
+     * The name must be a valid DNS subdomain name.
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+     */
+    readonly name: string;
+    /**
+     * The path on the container where the volume is mounted.
+     *
+     * @default - the volume is not mounted
+     */
+    readonly mountPath?: string;
+    /**
+     * If specified, the container has readonly access to the volume.
+     * Otherwise, the container has read/write access.
+     *
+     * @default false
+     */
+    readonly readonly?: boolean;
+}
+/**
+ * A Volume that can be mounted to a container supported by EKS
+ */
+export declare abstract class EksVolume {
+    /**
+     * Creates a Kubernetes EmptyDir volume
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
+     */
+    static emptyDir(options: EmptyDirVolumeOptions): EmptyDirVolume;
+    /**
+     * Creates a Kubernetes HostPath volume
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+     */
+    static hostPath(options: HostPathVolumeOptions): HostPathVolume;
+    /**
+     * Creates a Kubernetes Secret volume
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#secret
+     */
+    static secret(options: SecretPathVolumeOptions): SecretPathVolume;
+    /**
+     * The name of this volume.
+     * The name must be a valid DNS subdomain name.
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+     */
+    readonly name: string;
+    /**
+     * The path on the container where the container is mounted.
+     *
+     * @default - the container is not mounted
+     */
+    readonly containerPath?: string;
+    /**
+     * If specified, the container has readonly access to the volume.
+     * Otherwise, the container has read/write access.
+     *
+     * @default false
+     */
+    readonly readonly?: boolean;
+    constructor(options: EksVolumeOptions);
+}
+/**
+ * Options for a Kubernetes EmptyDir volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
+ */
+export interface EmptyDirVolumeOptions extends EksVolumeOptions {
+    /**
+     * The storage type to use for this Volume.
+     *
+     * @default `EmptyDirMediumType.DISK`
+     */
+    readonly medium?: EmptyDirMediumType;
+    /**
+     * The maximum size for this Volume
+     *
+     * @default - no size limit
+     */
+    readonly sizeLimit?: Size;
+}
+/**
+ * What medium the volume will live in
+ */
+export declare enum EmptyDirMediumType {
+    /**
+     * Use the disk storage of the node.
+     * Items written here will survive node reboots.
+     */
+    DISK = "",
+    /**
+     * Use the `tmpfs` volume that is backed by RAM of the node.
+     * Items written here will *not* survive node reboots.
+     */
+    MEMORY = "Memory"
+}
+/**
+ * A Kubernetes EmptyDir volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
+ */
+export declare class EmptyDirVolume extends EksVolume {
+    /**
+     * Returns `true` if `x` is an EmptyDirVolume, `false` otherwise
+     */
+    static isEmptyDirVolume(x: any): x is EmptyDirVolume;
+    /**
+     * The storage type to use for this Volume.
+     *
+     * @default `EmptyDirMediumType.DISK`
+     */
+    readonly medium?: EmptyDirMediumType;
+    /**
+     * The maximum size for this Volume
+     *
+     * @default - no size limit
+     */
+    readonly sizeLimit?: Size;
+    constructor(options: EmptyDirVolumeOptions);
+}
+/**
+ * Options for a kubernetes HostPath volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+ */
+export interface HostPathVolumeOptions extends EksVolumeOptions {
+    /**
+     * The path of the file or directory on the host to mount into containers on the pod.
+     *
+     * *Note*: HothPath Volumes present many security risks, and should be avoided when possible.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+     */
+    readonly hostPath: string;
+}
+/**
+ * A Kubernetes HostPath volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+ */
+export declare class HostPathVolume extends EksVolume {
+    /**
+     * returns `true` if `x` is a HostPathVolume, `false` otherwise
+     */
+    static isHostPathVolume(x: any): x is HostPathVolume;
+    /**
+     * The path of the file or directory on the host to mount into containers on the pod.
+     *
+     * *Note*: HothPath Volumes present many security risks, and should be avoided when possible.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+     */
+    readonly path: string;
+    constructor(options: HostPathVolumeOptions);
+}
+/**
+ * Options for a Kubernetes SecretPath Volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#secret
+ */
+export interface SecretPathVolumeOptions extends EksVolumeOptions {
+    /**
+     * The name of the secret.
+     * Must be a valid DNS subdomain name.
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+     */
+    readonly secretName: string;
+    /**
+     * Specifies whether the secret or the secret's keys must be defined
+     *
+     * @default true
+     */
+    readonly optional?: boolean;
+}
+/**
+ * Specifies the configuration of a Kubernetes secret volume
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes/#secret
+ */
+export declare class SecretPathVolume extends EksVolume {
+    /**
+     * returns `true` if `x` is a `SecretPathVolume` and `false` otherwise
+     */
+    static isSecretPathVolume(x: any): x is SecretPathVolume;
+    /**
+     * The name of the secret.
+     * Must be a valid DNS subdomain name.
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+     */
+    readonly secretName: string;
+    /**
+     * Specifies whether the secret or the secret's keys must be defined
+     *
+     * @default true
+     */
+    readonly optional?: boolean;
+    constructor(options: SecretPathVolumeOptions);
+}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/eks-job-definition.d.ts

@@ -0,0 +1,127 @@
+import type { Construct } from 'constructs';
+import type { EksContainerDefinition } from './eks-container-definition';
+import type { IJobDefinition, JobDefinitionProps } from './job-definition-base';
+import { JobDefinitionBase } from './job-definition-base';
+/**
+ * A JobDefinition that uses Eks orchestration
+ */
+export interface IEksJobDefinition extends IJobDefinition {
+    /**
+     * The container this Job Definition will run
+     */
+    readonly container: EksContainerDefinition;
+    /**
+     * The DNS Policy of the pod used by this Job Definition
+     *
+     * @see https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy
+     *
+     * @default `DnsPolicy.CLUSTER_FIRST`
+     */
+    readonly dnsPolicy?: DnsPolicy;
+    /**
+     * If specified, the Pod used by this Job Definition will use the host's network IP address.
+     * Otherwise, the Kubernetes pod networking model is enabled.
+     * Most AWS Batch workloads are egress-only and don't require the overhead of IP allocation for each pod for incoming connections.
+     *
+     * @default true
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#host-namespaces
+     * @see https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking
+     */
+    readonly useHostNetwork?: boolean;
+    /**
+     * The name of the service account that's used to run the container.
+     * service accounts are Kubernetes method of identification and authentication,
+     * roughly analogous to IAM users.
+     *
+     * @see https://docs.aws.amazon.com/eks/latest/userguide/service-accounts.html
+     * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
+     * @see https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html
+     *
+     * @default - the default service account of the container
+     */
+    readonly serviceAccount?: string;
+}
+/**
+ * Props for EksJobDefinition
+ */
+export interface EksJobDefinitionProps extends JobDefinitionProps {
+    /**
+     * The container this Job Definition will run
+     */
+    readonly container: EksContainerDefinition;
+    /**
+     * The DNS Policy of the pod used by this Job Definition
+     *
+     * @see https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy
+     *
+     * @default `DnsPolicy.CLUSTER_FIRST`
+     */
+    readonly dnsPolicy?: DnsPolicy;
+    /**
+     * If specified, the Pod used by this Job Definition will use the host's network IP address.
+     * Otherwise, the Kubernetes pod networking model is enabled.
+     * Most AWS Batch workloads are egress-only and don't require the overhead of IP allocation for each pod for incoming connections.
+     *
+     * @default true
+     *
+     * @see https://kubernetes.io/docs/concepts/security/pod-security-policy/#host-namespaces
+     * @see https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking
+     */
+    readonly useHostNetwork?: boolean;
+    /**
+     * The name of the service account that's used to run the container.
+     * service accounts are Kubernetes method of identification and authentication,
+     * roughly analogous to IAM users.
+     *
+     * @see https://docs.aws.amazon.com/eks/latest/userguide/service-accounts.html
+     * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
+     * @see https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html
+     *
+     * @default - the default service account of the container
+     */
+    readonly serviceAccount?: string;
+}
+/**
+ * The DNS Policy for the pod used by the Job Definition
+ *
+ * @see https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy
+ */
+export declare enum DnsPolicy {
+    /**
+     * The Pod inherits the name resolution configuration from the node that the Pods run on
+     */
+    DEFAULT = "Default",
+    /**
+     * Any DNS query that does not match the configured cluster domain suffix, such as `"www.kubernetes.io"`,
+     * is forwarded to an upstream nameserver by the DNS server.
+     * Cluster administrators may have extra stub-domain and upstream DNS servers configured.
+     */
+    CLUSTER_FIRST = "ClusterFirst",
+    /**
+     * For Pods running with `hostNetwork`, you should explicitly set its DNS policy to `CLUSTER_FIRST_WITH_HOST_NET`.
+     * Otherwise, Pods running with `hostNetwork` and `CLUSTER_FIRST` will fallback to the behavior of the `DEFAULT` policy.
+     */
+    CLUSTER_FIRST_WITH_HOST_NET = "ClusterFirstWithHostNet"
+}
+/**
+ * A JobDefinition that uses Eks orchestration
+ *
+ * @resource AWS::Batch::JobDefinition
+ */
+export declare class EksJobDefinition extends JobDefinitionBase implements IEksJobDefinition {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an EksJobDefinition by its arn
+     */
+    static fromEksJobDefinitionArn(scope: Construct, id: string, eksJobDefinitionArn: string): IEksJobDefinition;
+    readonly container: EksContainerDefinition;
+    readonly dnsPolicy?: DnsPolicy;
+    readonly useHostNetwork?: boolean;
+    readonly serviceAccount?: string;
+    private readonly resource;
+    get jobDefinitionArn(): string;
+    get jobDefinitionName(): string;
+    constructor(scope: Construct, id: string, props: EksJobDefinitionProps);
+}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './ecs-job-definition';
+export * from './compute-environment-base';
+export * from './eks-job-definition';
+export * from './ecs-container-definition';
+export * from './eks-container-definition';
+export * from './job-definition-base';
+export * from './job-queue';
+export * from './linux-parameters';
+export * from './managed-compute-environment';
+export * from './multinode-job-definition';
+export * from './scheduling-policy';
+export * from './unmanaged-compute-environment';
+export * from './batch.generated';

cdk/node_modules/aws-cdk-lib/aws-batch/lib/job-definition-base.d.ts

@@ -0,0 +1,235 @@
+import type { Construct } from 'constructs';
+import type { CfnJobDefinitionProps } from './batch.generated';
+import type { Duration, IResource } from '../../core';
+import { Resource } from '../../core';
+import type { IJobDefinitionRef, JobDefinitionReference } from '../../interfaces/generated/aws-batch-interfaces.generated';
+/**
+ * Represents a JobDefinition
+ */
+export interface IJobDefinition extends IResource, IJobDefinitionRef {
+    /**
+     * The ARN of this job definition
+     *
+     * @attribute
+     */
+    readonly jobDefinitionArn: string;
+    /**
+     * The name of this job definition
+     *
+     * @attribute
+     */
+    readonly jobDefinitionName: string;
+    /**
+     * The default parameters passed to the container
+     * These parameters can be referenced in the `command` that
+     * you give to the container
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html#parameters
+     *
+     * @default none
+     */
+    readonly parameters?: {
+        [key: string]: any;
+    };
+    /**
+     * The number of times to retry a job.
+     * The job is retried on failure the same number of attempts as the value.
+     *
+     * @default 1
+     */
+    readonly retryAttempts?: number;
+    /**
+     * Defines the retry behavior for this job
+     *
+     * @default - no `RetryStrategy`
+     */
+    readonly retryStrategies: RetryStrategy[];
+    /**
+     * The priority of this Job. Only used in Fairshare Scheduling
+     * to decide which job to run first when there are multiple jobs
+     * with the same share identifier.
+     *
+     * @default none
+     */
+    readonly schedulingPriority?: number;
+    /**
+     * The timeout time for jobs that are submitted with this job definition.
+     * After the amount of time you specify passes,
+     * Batch terminates your jobs if they aren't finished.
+     *
+     * @default - no timeout
+     */
+    readonly timeout?: Duration;
+    /**
+     * Add a RetryStrategy to this JobDefinition
+     */
+    addRetryStrategy(strategy: RetryStrategy): void;
+}
+/**
+ * Props common to all JobDefinitions
+ */
+export interface JobDefinitionProps {
+    /**
+     * The name of this job definition
+     *
+     * @default - generated by CloudFormation
+     */
+    readonly jobDefinitionName?: string;
+    /**
+     * The default parameters passed to the container
+     * These parameters can be referenced in the `command` that
+     * you give to the container
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html#parameters
+     *
+     * @default none
+     */
+    readonly parameters?: {
+        [key: string]: any;
+    };
+    /**
+     * The number of times to retry a job.
+     * The job is retried on failure the same number of attempts as the value.
+     *
+     * @default 1
+     */
+    readonly retryAttempts?: number;
+    /**
+     * Defines the retry behavior for this job
+     *
+     * @default - no `RetryStrategy`
+     */
+    readonly retryStrategies?: RetryStrategy[];
+    /**
+     * The priority of this Job. Only used in Fairshare Scheduling
+     * to decide which job to run first when there are multiple jobs
+     * with the same share identifier.
+     *
+     * @default none
+     */
+    readonly schedulingPriority?: number;
+    /**
+     * The timeout time for jobs that are submitted with this job definition.
+     * After the amount of time you specify passes,
+     * Batch terminates your jobs if they aren't finished.
+     *
+     * @default - no timeout
+     */
+    readonly timeout?: Duration;
+    /**
+     * Specifies whether the previous revision of the job definition is retained in an active status after UPDATE events for the resource.
+     *
+     * When the property is set to false, the previous revision of the job definition is de-registered after a new revision is created.
+     * When the property is set to true, the previous revision of the job definition is not de-registered.
+     *
+     * @default undefined - AWS Batch default is false
+     */
+    readonly skipDeregisterOnUpdate?: boolean;
+}
+/**
+ * Define how Jobs using this JobDefinition respond to different exit conditions
+ */
+export declare class RetryStrategy {
+    /**
+     * Create a new RetryStrategy
+     */
+    static of(action: Action, on: Reason): RetryStrategy;
+    /**
+     * The action to take when the job exits with the Reason specified
+     */
+    readonly action: Action;
+    /**
+     * If the job exits with this Reason it will trigger the specified Action
+     */
+    readonly on: Reason;
+    constructor(action: Action, on: Reason);
+}
+/**
+ * The Action to take when all specified conditions in a RetryStrategy are met
+ */
+export declare enum Action {
+    /**
+     * The job will not retry
+     */
+    EXIT = "EXIT",
+    /**
+     * The job will retry. It can be retried up to the number of times specified in `retryAttempts`.
+     */
+    RETRY = "RETRY"
+}
+/**
+ * The corresponding Action will only be taken if *all* of the conditions specified here are met.
+ */
+export interface CustomReason {
+    /**
+     * A glob string that will match on the job exit code. For example, `'40*'` will match 400, 404, 40123456789012
+     *
+     * @default - will not match on the exit code
+     */
+    readonly onExitCode?: string;
+    /**
+     * A glob string that will match on the statusReason returned by the exiting job.
+     * For example, `'Host EC2*'` indicates that the spot instance has been reclaimed.
+     *
+     * @default - will not match on the status reason
+     */
+    readonly onStatusReason?: string;
+    /**
+     * A glob string that will match on the reason returned by the exiting job
+     * For example, `'CannotPullContainerError*'` indicates that container needed to start the job could not be pulled.
+     *
+     * @default - will not match on the reason
+     */
+    readonly onReason?: string;
+}
+/**
+ * Common job exit reasons
+ */
+export declare class Reason {
+    /**
+     * Will match any non-zero exit code
+     */
+    static readonly NON_ZERO_EXIT_CODE: Reason;
+    /**
+     * Will only match if the Docker container could not be pulled
+     */
+    static readonly CANNOT_PULL_CONTAINER: Reason;
+    /**
+     * Will only match if the Spot instance executing the job was reclaimed
+     */
+    static readonly SPOT_INSTANCE_RECLAIMED: Reason;
+    /**
+     * A custom Reason that can match on multiple conditions.
+     * Note that all specified conditions must be met for this reason to match.
+     */
+    static custom(customReasonProps: CustomReason): Reason;
+}
+/**
+ * Abstract base class for JobDefinitions
+ *
+ * @internal
+ */
+export declare abstract class JobDefinitionBase extends Resource implements IJobDefinition {
+    abstract readonly jobDefinitionArn: string;
+    abstract readonly jobDefinitionName: string;
+    readonly parameters?: {
+        [key: string]: any;
+    };
+    readonly retryAttempts?: number;
+    readonly retryStrategies: RetryStrategy[];
+    readonly schedulingPriority?: number;
+    readonly timeout?: Duration;
+    /**
+     * Specifies whether the previous revision of the job definition is retained in an active status after UPDATE events for the resource.
+     *
+     * @default undefined - AWS Batch default is false
+     */
+    readonly skipDeregisterOnUpdate?: boolean;
+    get jobDefinitionRef(): JobDefinitionReference;
+    constructor(scope: Construct, id: string, props?: JobDefinitionProps);
+    addRetryStrategy(strategy: RetryStrategy): void;
+}
+/**
+ * @internal
+ */
+export declare function baseJobDefinitionProperties(baseJobDefinition: JobDefinitionBase): CfnJobDefinitionProps;

cdk/node_modules/aws-cdk-lib/aws-batch/lib/job-definition-base.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.JobDefinitionBase=exports.Reason=exports.Action=exports.RetryStrategy=void 0,exports.baseJobDefinitionProperties=baseJobDefinitionProperties;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp};class RetryStrategy{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_batch.RetryStrategy",version:"2.252.0"};static of(action,on){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Action(action),jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Reason(on)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.of),error}return new RetryStrategy(action,on)}action;on;constructor(action,on){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Action(action),jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Reason(on)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,RetryStrategy),error}this.action=action,this.on=on}}exports.RetryStrategy=RetryStrategy;var Action;(function(Action2){Action2.EXIT="EXIT",Action2.RETRY="RETRY"})(Action||(exports.Action=Action={}));class Reason{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_batch.Reason",version:"2.252.0"};static NON_ZERO_EXIT_CODE={onExitCode:"*"};static CANNOT_PULL_CONTAINER={onReason:"CannotPullContainerError:*"};static SPOT_INSTANCE_RECLAIMED={onStatusReason:"Host EC2*"};static custom(customReasonProps){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_CustomReason(customReasonProps)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.custom),error}return customReasonProps}}exports.Reason=Reason;class JobDefinitionBase extends core_1().Resource{parameters;retryAttempts;retryStrategies;schedulingPriority;timeout;skipDeregisterOnUpdate;get jobDefinitionRef(){return{jobDefinitionArn:this.jobDefinitionArn}}constructor(scope,id,props){super(scope,id,{physicalName:props?.jobDefinitionName}),this.parameters=props?.parameters,this.retryAttempts=props?.retryAttempts,this.retryStrategies=props?.retryStrategies??[],this.schedulingPriority=props?.schedulingPriority,this.timeout=props?.timeout,this.skipDeregisterOnUpdate=props?.skipDeregisterOnUpdate}addRetryStrategy(strategy){this.retryStrategies.push(strategy)}}exports.JobDefinitionBase=JobDefinitionBase;function baseJobDefinitionProperties(baseJobDefinition){return{parameters:baseJobDefinition.parameters,retryStrategy:{attempts:baseJobDefinition.retryAttempts,evaluateOnExit:core_1().Lazy.any({produce:()=>{if(baseJobDefinition.retryStrategies.length!==0)return baseJobDefinition.retryStrategies.map(strategy=>({action:strategy.action,...strategy.on}))}})},schedulingPriority:baseJobDefinition.schedulingPriority,timeout:{attemptDurationSeconds:baseJobDefinition.timeout?.toSeconds()},type:"dummy",resourceRetentionPolicy:baseJobDefinition.skipDeregisterOnUpdate!==void 0?{skipDeregisterOnUpdate:baseJobDefinition.skipDeregisterOnUpdate}:void 0}}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/job-queue.d.ts

@@ -0,0 +1,232 @@
+import type { Construct } from 'constructs';
+import type { ISchedulingPolicy } from './scheduling-policy';
+import type { Duration, IResource } from '../../core';
+import { Resource } from '../../core';
+import type { IComputeEnvironmentRef, IJobQueueRef, ISchedulingPolicyRef, JobQueueReference } from '../../interfaces/generated/aws-batch-interfaces.generated';
+/**
+ * Represents a JobQueue
+ */
+export interface IJobQueue extends IResource, IJobQueueRef {
+    /**
+     * The name of the job queue. It can be up to 128 letters long.
+     * It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_)
+     *
+     * @attribute
+     */
+    readonly jobQueueName: string;
+    /**
+     * The ARN of this job queue
+     *
+     * @attribute
+     */
+    readonly jobQueueArn: string;
+    /**
+     * The set of compute environments mapped to a job queue and their order relative to each other.
+     * The job scheduler uses this parameter to determine which compute environment runs a specific job.
+     * Compute environments must be in the VALID state before you can associate them with a job queue.
+     * You can associate up to three compute environments with a job queue.
+     * All of the compute environments must be either EC2 (EC2 or SPOT) or Fargate (FARGATE or FARGATE_SPOT);
+     * EC2 and Fargate compute environments can't be mixed.
+     *
+     * *Note*: All compute environments that are associated with a job queue must share the same architecture.
+     * AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
+     */
+    readonly computeEnvironments: OrderedComputeEnvironment[];
+    /**
+     * The priority of the job queue.
+     * Job queues with a higher priority are evaluated first when associated with the same compute environment.
+     * Priority is determined in descending order.
+     * For example, a job queue with a priority value of 10 is given scheduling preference over a job queue with a priority value of 1.
+     */
+    readonly priority: number;
+    /**
+     * If the job queue is enabled, it is able to accept jobs.
+     * Otherwise, new jobs can't be added to the queue, but jobs already in the queue can finish.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The SchedulingPolicy for this JobQueue. Instructs the Scheduler how to schedule different jobs.
+     *
+     * @default - no scheduling policy
+     */
+    readonly schedulingPolicy?: ISchedulingPolicy;
+    /**
+     * Add a `ComputeEnvironment` to this Queue.
+     * The Queue will prefer lower-order `ComputeEnvironment`s.
+     */
+    addComputeEnvironment(computeEnvironment: IComputeEnvironmentRef, order: number): void;
+}
+/**
+ * Props to configure a JobQueue
+ */
+export interface JobQueueProps {
+    /**
+     * The set of compute environments mapped to a job queue and their order relative to each other.
+     * The job scheduler uses this parameter to determine which compute environment runs a specific job.
+     * Compute environments must be in the VALID state before you can associate them with a job queue.
+     * You can associate up to three compute environments with a job queue.
+     * All of the compute environments must be either EC2 (EC2 or SPOT) or Fargate (FARGATE or FARGATE_SPOT);
+     * EC2 and Fargate compute environments can't be mixed.
+     *
+     * *Note*: All compute environments that are associated with a job queue must share the same architecture.
+     * AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
+     *
+     * @default none
+     */
+    readonly computeEnvironments?: OrderedComputeEnvironment[];
+    /**
+     * The priority of the job queue.
+     * Job queues with a higher priority are evaluated first when associated with the same compute environment.
+     * Priority is determined in descending order.
+     * For example, a job queue with a priority of 10 is given scheduling preference over a job queue with a priority of 1.
+     *
+     * @default 1
+     */
+    readonly priority?: number;
+    /**
+     * The name of the job queue. It can be up to 128 letters long.
+     * It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_)
+     *
+     * @default - no name
+     */
+    readonly jobQueueName?: string;
+    /**
+     * If the job queue is enabled, it is able to accept jobs.
+     * Otherwise, new jobs can't be added to the queue, but jobs already in the queue can finish.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The SchedulingPolicy for this JobQueue. Instructs the Scheduler how to schedule different jobs.
+     *
+     * @default - no scheduling policy
+     */
+    readonly schedulingPolicy?: ISchedulingPolicyRef;
+    /**
+     * The set of actions that AWS Batch perform on jobs that remain at the head of the job queue in
+     * the specified state longer than specified times.
+     *
+     * @default - no actions
+     */
+    readonly jobStateTimeLimitActions?: JobStateTimeLimitAction[];
+}
+/**
+ * Assigns an order to a ComputeEnvironment.
+ * The JobQueue will prioritize the lowest-order ComputeEnvironment.
+ */
+export interface OrderedComputeEnvironment {
+    /**
+     * The ComputeEnvironment to link to this JobQueue
+     */
+    readonly computeEnvironment: IComputeEnvironmentRef;
+    /**
+     * The order associated with `computeEnvironment`
+     */
+    readonly order: number;
+}
+/**
+ * Specifies an action that AWS Batch will take after the job has remained at
+ * the head of the queue in the specified state for longer than the specified time.
+ */
+export interface JobStateTimeLimitAction {
+    /**
+     * The action to take when a job is at the head of the job queue in the specified state
+     * for the specified period of time.
+     *
+     * @default JobStateTimeLimitActionsAction.CANCEL
+     */
+    readonly action?: JobStateTimeLimitActionsAction;
+    /**
+     * The approximate amount of time, that must pass with the job in the specified
+     * state before the action is taken.
+     *
+     * The minimum value is 10 minutes and the maximum value is 24 hours.
+     */
+    readonly maxTime: Duration;
+    /**
+     * The reason to log for the action being taken.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#job_stuck_in_runnable
+     */
+    readonly reason: JobStateTimeLimitActionsReason;
+    /**
+     * The state of the job needed to trigger the action.
+     *
+     * @default JobStateTimeLimitActionsState.RUNNABLE
+     */
+    readonly state?: JobStateTimeLimitActionsState;
+}
+/**
+ * The action to take when a job is at the head of the job queue in the specified state
+ * for the specified period of time.
+ */
+export declare enum JobStateTimeLimitActionsAction {
+    /**
+     * Cancel the job.
+     */
+    CANCEL = "CANCEL",
+    /**
+     * Terminate the job.
+     */
+    TERMINATE = "TERMINATE"
+}
+/**
+ * The reason to log for the action being taken.
+ *
+ * @see https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#job_stuck_in_runnable
+ */
+export declare enum JobStateTimeLimitActionsReason {
+    /**
+     * All connected compute environments have insufficient capacity errors.
+     */
+    INSUFFICIENT_INSTANCE_CAPACITY = "CAPACITY:INSUFFICIENT_INSTANCE_CAPACITY",
+    /**
+     * All compute environments have a maxvCpus parameter that is smaller than the job requirements.
+     */
+    COMPUTE_ENVIRONMENT_MAX_RESOURCE = "MISCONFIGURATION:COMPUTE_ENVIRONMENT_MAX_RESOURCE",
+    /**
+     * None of the compute environments have instances that meet the job requirements.
+     */
+    JOB_RESOURCE_REQUIREMENT = "MISCONFIGURATION:JOB_RESOURCE_REQUIREMENT"
+}
+/**
+ * The state of the job needed to trigger the action.
+ */
+export declare enum JobStateTimeLimitActionsState {
+    /**
+     * RUNNABLE state triggers the action.
+     */
+    RUNNABLE = "RUNNABLE"
+}
+/**
+ * JobQueues can receive Jobs, which are removed from the queue when
+ * sent to the linked ComputeEnvironment(s) to be executed.
+ * Jobs exit the queue in FIFO order unless a `SchedulingPolicy` is linked.
+ */
+export declare class JobQueue extends Resource implements IJobQueue {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * refer to an existing JobQueue by its arn
+     */
+    static fromJobQueueArn(scope: Construct, id: string, jobQueueArn: string): IJobQueue;
+    private readonly _computeEnvironments;
+    readonly priority: number;
+    readonly enabled?: boolean;
+    private readonly _schedulingPolicy?;
+    private readonly resource;
+    get jobQueueArn(): string;
+    get computeEnvironments(): OrderedComputeEnvironment[];
+    get jobQueueName(): string;
+    /**
+     * The SchedulingPolicy for this JobQueue. Instructs the Scheduler how to schedule different jobs.
+     */
+    get schedulingPolicy(): ISchedulingPolicy | undefined;
+    get jobQueueRef(): JobQueueReference;
+    constructor(scope: Construct, id: string, props?: JobQueueProps);
+    addComputeEnvironment(computeEnvironment: IComputeEnvironmentRef, order: number): void;
+    private renderJobStateTimeLimitActions;
+}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/linux-parameters.d.ts

@@ -0,0 +1,196 @@
+import { Construct } from 'constructs';
+import type { CfnJobDefinition } from './batch.generated';
+import * as cdk from '../../core';
+/**
+ * The properties for defining Linux-specific options that are applied to the container.
+ */
+export interface LinuxParametersProps {
+    /**
+     * Specifies whether to run an init process inside the container that forwards signals and reaps processes.
+     *
+     * @default false
+     */
+    readonly initProcessEnabled?: boolean;
+    /**
+     * The value for the size of the /dev/shm volume.
+     *
+     * @default No shared memory.
+     */
+    readonly sharedMemorySize?: cdk.Size;
+    /**
+     * The total amount of swap memory a container can use. This parameter
+     * will be translated to the --memory-swap option to docker run.
+     *
+     * This parameter is only supported when you are using the EC2 launch type.
+     * Accepted values are positive integers.
+     *
+     * @default No swap.
+     */
+    readonly maxSwap?: cdk.Size;
+    /**
+     * This allows you to tune a container's memory swappiness behavior. This parameter
+     * maps to the --memory-swappiness option to docker run. The swappiness relates
+     * to the kernel's tendency to swap memory. A value of 0 will cause swapping to
+     * not happen unless absolutely necessary. A value of 100 will cause pages to
+     * be swapped very aggressively.
+     *
+     * This parameter is only supported when you are using the EC2 launch type.
+     * Accepted values are whole numbers between 0 and 100. If a value is not
+     * specified for maxSwap then this parameter is ignored.
+     *
+     * @default 60
+     */
+    readonly swappiness?: number;
+}
+/**
+ * Linux-specific options that are applied to the container.
+ */
+export declare class LinuxParameters extends Construct {
+    /**
+     * Whether the init process is enabled
+     */
+    protected readonly initProcessEnabled?: boolean;
+    /**
+     * The shared memory size (in MiB). Not valid for Fargate launch type
+     */
+    protected readonly sharedMemorySize?: cdk.Size;
+    /**
+     * The max swap memory
+     */
+    protected readonly maxSwap?: cdk.Size;
+    /**
+     * The swappiness behavior
+     */
+    protected readonly swappiness?: number;
+    /**
+     * Device mounts
+     */
+    protected readonly devices: Device[];
+    /**
+     * TmpFs mounts
+     */
+    protected readonly tmpfs: Tmpfs[];
+    /**
+     * Constructs a new instance of the LinuxParameters class.
+     */
+    constructor(scope: Construct, id: string, props?: LinuxParametersProps);
+    private validateProps;
+    /**
+     * Adds one or more host devices to a container.
+     */
+    addDevices(...device: Device[]): void;
+    /**
+     * Specifies the container path, mount options, and size (in MiB) of the tmpfs mount for a container.
+     *
+     * Only works with EC2 launch type.
+     */
+    addTmpfs(...tmpfs: Tmpfs[]): void;
+    /**
+     * Renders the Linux parameters to the Batch version of this resource,
+     * which does not have 'capabilities' and requires tmpfs.containerPath to be defined.
+     */
+    renderLinuxParameters(): CfnJobDefinition.LinuxParametersProperty;
+}
+/**
+ * A container instance host device.
+ */
+export interface Device {
+    /**
+     * The path inside the container at which to expose the host device.
+     *
+     * @default Same path as the host
+     */
+    readonly containerPath?: string;
+    /**
+     * The path for the device on the host container instance.
+     */
+    readonly hostPath: string;
+    /**
+     * The explicit permissions to provide to the container for the device.
+     * By default, the container has permissions for read, write, and mknod for the device.
+     *
+     * @default Readonly
+     */
+    readonly permissions?: DevicePermission[];
+}
+/**
+ * The details of a tmpfs mount for a container.
+ */
+export interface Tmpfs {
+    /**
+     * The absolute file path where the tmpfs volume is to be mounted.
+     */
+    readonly containerPath: string;
+    /**
+     * The size (in MiB) of the tmpfs volume.
+     */
+    readonly size: cdk.Size;
+    /**
+     * The list of tmpfs volume mount options. For more information, see
+     * [TmpfsMountOptions](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Tmpfs.html).
+     *
+     * @default none
+     */
+    readonly mountOptions?: TmpfsMountOption[];
+}
+/**
+ * Permissions for device access
+ */
+export declare enum DevicePermission {
+    /**
+     * Read
+     */
+    READ = "read",
+    /**
+     * Write
+     */
+    WRITE = "write",
+    /**
+     * Make a node
+     */
+    MKNOD = "mknod"
+}
+/**
+ * The supported options for a tmpfs mount for a container.
+ */
+export declare enum TmpfsMountOption {
+    DEFAULTS = "defaults",
+    RO = "ro",
+    RW = "rw",
+    SUID = "suid",
+    NOSUID = "nosuid",
+    DEV = "dev",
+    NODEV = "nodev",
+    EXEC = "exec",
+    NOEXEC = "noexec",
+    SYNC = "sync",
+    ASYNC = "async",
+    DIRSYNC = "dirsync",
+    REMOUNT = "remount",
+    MAND = "mand",
+    NOMAND = "nomand",
+    ATIME = "atime",
+    NOATIME = "noatime",
+    DIRATIME = "diratime",
+    NODIRATIME = "nodiratime",
+    BIND = "bind",
+    RBIND = "rbind",
+    UNBINDABLE = "unbindable",
+    RUNBINDABLE = "runbindable",
+    PRIVATE = "private",
+    RPRIVATE = "rprivate",
+    SHARED = "shared",
+    RSHARED = "rshared",
+    SLAVE = "slave",
+    RSLAVE = "rslave",
+    RELATIME = "relatime",
+    NORELATIME = "norelatime",
+    STRICTATIME = "strictatime",
+    NOSTRICTATIME = "nostrictatime",
+    MODE = "mode",
+    UID = "uid",
+    GID = "gid",
+    NR_INODES = "nr_inodes",
+    NR_BLOCKS = "nr_blocks",
+    MPOL = "mpol"
+}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/linux-parameters.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.TmpfsMountOption=exports.DevicePermission=exports.LinuxParameters=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var constructs_1=()=>{var tmp=require("constructs");return constructs_1=()=>tmp,tmp},cdk=()=>{var tmp=require("../../core");return cdk=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class LinuxParameters extends constructs_1().Construct{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_batch.LinuxParameters",version:"2.252.0"};initProcessEnabled;sharedMemorySize;maxSwap;swappiness;devices=new Array;tmpfs=new Array;constructor(scope,id,props={}){super(scope,id);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_LinuxParametersProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,LinuxParameters),error}this.validateProps(props),this.sharedMemorySize=props.sharedMemorySize,this.initProcessEnabled=props.initProcessEnabled,this.maxSwap=props.maxSwap,this.swappiness=props.maxSwap?props.swappiness:void 0}validateProps(props){if(!cdk().Token.isUnresolved(props.swappiness)&&props.swappiness!==void 0&&(!Number.isInteger(props.swappiness)||props.swappiness<0||props.swappiness>100))throw new(cdk()).ValidationError((0,literal_string_1().lit)`InvalidSwappiness`,`swappiness: Must be an integer between 0 and 100; received ${props.swappiness}.`,this)}addDevices(...device){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Device(device)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addDevices),error}this.devices.push(...device)}addTmpfs(...tmpfs){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_batch_Tmpfs(tmpfs)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addTmpfs),error}this.tmpfs.push(...tmpfs)}renderLinuxParameters(){return{initProcessEnabled:this.initProcessEnabled,sharedMemorySize:this.sharedMemorySize?.toMebibytes(),maxSwap:this.maxSwap?.toMebibytes(),swappiness:this.swappiness,devices:cdk().Lazy.any({produce:()=>this.devices.map(renderDevice)},{omitEmptyArray:!0}),tmpfs:cdk().Lazy.any({produce:()=>this.tmpfs.map(renderTmpfs)},{omitEmptyArray:!0})}}}exports.LinuxParameters=LinuxParameters;var DevicePermission;(function(DevicePermission2){DevicePermission2.READ="read",DevicePermission2.WRITE="write",DevicePermission2.MKNOD="mknod"})(DevicePermission||(exports.DevicePermission=DevicePermission={}));var TmpfsMountOption;(function(TmpfsMountOption2){TmpfsMountOption2.DEFAULTS="defaults",TmpfsMountOption2.RO="ro",TmpfsMountOption2.RW="rw",TmpfsMountOption2.SUID="suid",TmpfsMountOption2.NOSUID="nosuid",TmpfsMountOption2.DEV="dev",TmpfsMountOption2.NODEV="nodev",TmpfsMountOption2.EXEC="exec",TmpfsMountOption2.NOEXEC="noexec",TmpfsMountOption2.SYNC="sync",TmpfsMountOption2.ASYNC="async",TmpfsMountOption2.DIRSYNC="dirsync",TmpfsMountOption2.REMOUNT="remount",TmpfsMountOption2.MAND="mand",TmpfsMountOption2.NOMAND="nomand",TmpfsMountOption2.ATIME="atime",TmpfsMountOption2.NOATIME="noatime",TmpfsMountOption2.DIRATIME="diratime",TmpfsMountOption2.NODIRATIME="nodiratime",TmpfsMountOption2.BIND="bind",TmpfsMountOption2.RBIND="rbind",TmpfsMountOption2.UNBINDABLE="unbindable",TmpfsMountOption2.RUNBINDABLE="runbindable",TmpfsMountOption2.PRIVATE="private",TmpfsMountOption2.RPRIVATE="rprivate",TmpfsMountOption2.SHARED="shared",TmpfsMountOption2.RSHARED="rshared",TmpfsMountOption2.SLAVE="slave",TmpfsMountOption2.RSLAVE="rslave",TmpfsMountOption2.RELATIME="relatime",TmpfsMountOption2.NORELATIME="norelatime",TmpfsMountOption2.STRICTATIME="strictatime",TmpfsMountOption2.NOSTRICTATIME="nostrictatime",TmpfsMountOption2.MODE="mode",TmpfsMountOption2.UID="uid",TmpfsMountOption2.GID="gid",TmpfsMountOption2.NR_INODES="nr_inodes",TmpfsMountOption2.NR_BLOCKS="nr_blocks",TmpfsMountOption2.MPOL="mpol"})(TmpfsMountOption||(exports.TmpfsMountOption=TmpfsMountOption={}));function renderTmpfs(tmpfs){return{containerPath:tmpfs.containerPath,size:tmpfs.size.toMebibytes(),mountOptions:tmpfs.mountOptions}}function renderDevice(device){return{containerPath:device.containerPath,hostPath:device.hostPath,permissions:device.permissions}}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/managed-compute-environment.d.ts

@@ -0,0 +1,885 @@
+import type { Construct } from 'constructs';
+import type { IComputeEnvironment, ComputeEnvironmentProps } from './compute-environment-base';
+import { ComputeEnvironmentBase } from './compute-environment-base';
+import * as ec2 from '../../aws-ec2';
+import type * as eks from '../../aws-eks';
+import * as iam from '../../aws-iam';
+import type { Duration, ITaggable } from '../../core';
+import { TagManager } from '../../core';
+/**
+ * Represents a Managed ComputeEnvironment. Batch will provision EC2 Instances to
+ * meet the requirements of the jobs executing in this ComputeEnvironment.
+ */
+export interface IManagedComputeEnvironment extends IComputeEnvironment, ec2.IConnectable, ITaggable {
+    /**
+     * The maximum vCpus this `ManagedComputeEnvironment` can scale up to.
+     *
+     * *Note*: if this Compute Environment uses EC2 resources (not Fargate) with either `AllocationStrategy.BEST_FIT_PROGRESSIVE` or
+     * `AllocationStrategy.SPOT_CAPACITY_OPTIMIZED`, or `AllocationStrategy.BEST_FIT` with Spot instances,
+     * The scheduler may exceed this number by at most one of the instances specified in `instanceTypes`
+     * or `instanceClasses`.
+     */
+    readonly maxvCpus: number;
+    /**
+     * Specifies whether this Compute Environment is replaced if an update is made that requires
+     * replacing its instances. To enable more properties to be updated,
+     * set this property to `false`. When changing the value of this property to false,
+     * do not change any other properties at the same time.
+     * If other properties are changed at the same time,
+     * and the change needs to be rolled back but it can't,
+     * it's possible for the stack to go into the UPDATE_ROLLBACK_FAILED state.
+     * You can't update a stack that is in the UPDATE_ROLLBACK_FAILED state.
+     * However, if you can continue to roll it back,
+     * you can return the stack to its original settings and then try to update it again.
+     *
+     * The properties which require a replacement of the Compute Environment are:
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-computeenvironment.html#cfn-batch-computeenvironment-replacecomputeenvironment
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html
+     */
+    readonly replaceComputeEnvironment?: boolean;
+    /**
+     * Whether or not to use spot instances.
+     * Spot instances are less expensive EC2 instances that can be
+     * reclaimed by EC2 at any time; your job will be given two minutes
+     * of notice before reclamation.
+     *
+     * @default false
+     */
+    readonly spot?: boolean;
+    /**
+     * Only meaningful if `terminateOnUpdate` is `false`. If so,
+     * when an infrastructure update is triggered, any running jobs
+     * will be allowed to run until `updateTimeout` has expired.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
+     * @default 30 minutes
+     */
+    readonly updateTimeout?: Duration;
+    /**
+     * Whether or not any running jobs will be immediately terminated when an infrastructure update
+     * occurs. If this is enabled, any terminated jobs may be retried, depending on the job's
+     * retry policy.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
+     *
+     * @default false
+     */
+    readonly terminateOnUpdate?: boolean;
+    /**
+     * The security groups this Compute Environment will launch instances in.
+     */
+    readonly securityGroups: ec2.ISecurityGroup[];
+    /**
+     * The VPC Subnets this Compute Environment will launch instances in.
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * Whether or not the AMI is updated to the latest one supported by Batch
+     * when an infrastructure update occurs.
+     *
+     * If you specify a specific AMI, this property will be ignored.
+     *
+     * Note: the CDK will never set this value by default, `false` will set by CFN.
+     * This is to avoid a deployment failure that occurs when this value is set.
+     *
+     * @see https://github.com/aws/aws-cdk/issues/27054
+     *
+     * @default false
+     */
+    readonly updateToLatestImageVersion?: boolean;
+}
+/**
+ * Props for a ManagedComputeEnvironment
+ */
+export interface ManagedComputeEnvironmentProps extends ComputeEnvironmentProps {
+    /**
+     * The maximum vCpus this `ManagedComputeEnvironment` can scale up to.
+     * Each vCPU is equivalent to 1024 CPU shares.
+     *
+     * *Note*: if this Compute Environment uses EC2 resources (not Fargate) with either `AllocationStrategy.BEST_FIT_PROGRESSIVE` or
+     * `AllocationStrategy.SPOT_CAPACITY_OPTIMIZED`, or `AllocationStrategy.BEST_FIT` with Spot instances,
+     * The scheduler may exceed this number by at most one of the instances specified in `instanceTypes`
+     * or `instanceClasses`.
+     *
+     * @default 256
+     */
+    readonly maxvCpus?: number;
+    /**
+     * Specifies whether this Compute Environment is replaced if an update is made that requires
+     * replacing its instances. To enable more properties to be updated,
+     * set this property to `false`. When changing the value of this property to false,
+     * do not change any other properties at the same time.
+     * If other properties are changed at the same time,
+     * and the change needs to be rolled back but it can't,
+     * it's possible for the stack to go into the UPDATE_ROLLBACK_FAILED state.
+     * You can't update a stack that is in the UPDATE_ROLLBACK_FAILED state.
+     * However, if you can continue to roll it back,
+     * you can return the stack to its original settings and then try to update it again.
+     *
+     * The properties which require a replacement of the Compute Environment are:
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-computeenvironment.html#cfn-batch-computeenvironment-replacecomputeenvironment
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html
+     *
+     * @default false
+     */
+    readonly replaceComputeEnvironment?: boolean;
+    /**
+     * Whether or not to use spot instances.
+     * Spot instances are less expensive EC2 instances that can be
+     * reclaimed by EC2 at any time; your job will be given two minutes
+     * of notice before reclamation.
+     *
+     * @default false
+     */
+    readonly spot?: boolean;
+    /**
+     * Only meaningful if `terminateOnUpdate` is `false`. If so,
+     * when an infrastructure update is triggered, any running jobs
+     * will be allowed to run until `updateTimeout` has expired.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
+     *
+     * @default 30 minutes
+     */
+    readonly updateTimeout?: Duration;
+    /**
+     * Whether or not any running jobs will be immediately terminated when an infrastructure update
+     * occurs. If this is enabled, any terminated jobs may be retried, depending on the job's
+     * retry policy.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html
+     *
+     * @default false
+     */
+    readonly terminateOnUpdate?: boolean;
+    /**
+     * VPC in which this Compute Environment will launch Instances
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * The security groups this Compute Environment will launch instances in.
+     *
+     * @default new security groups will be created
+     */
+    readonly securityGroups?: ec2.ISecurityGroup[];
+    /**
+     * The VPC Subnets this Compute Environment will launch instances in.
+     *
+     * @default new subnets will be created
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * Whether or not the AMI is updated to the latest one supported by Batch
+     * when an infrastructure update occurs.
+     *
+     * If you specify a specific AMI, this property will be ignored.
+     *
+     * Note: the CDK will never set this value by default, `false` will set by CFN.
+     * This is to avoid a deployment failure that occurs when this value is set.
+     *
+     * @see https://github.com/aws/aws-cdk/issues/27054
+     *
+     * @default false
+     */
+    readonly updateToLatestImageVersion?: boolean;
+}
+/**
+ * Abstract base class for ManagedComputeEnvironments
+ * @internal
+ */
+export declare abstract class ManagedComputeEnvironmentBase extends ComputeEnvironmentBase implements IManagedComputeEnvironment {
+    readonly maxvCpus: number;
+    readonly replaceComputeEnvironment?: boolean;
+    readonly spot?: boolean;
+    readonly updateTimeout?: Duration;
+    readonly terminateOnUpdate?: boolean;
+    readonly securityGroups: ec2.ISecurityGroup[];
+    readonly updateToLatestImageVersion?: boolean;
+    readonly tags: TagManager;
+    readonly connections: ec2.Connections;
+    constructor(scope: Construct, id: string, props: ManagedComputeEnvironmentProps);
+}
+/**
+ * A ManagedComputeEnvironment that uses ECS orchestration on EC2 instances.
+ */
+export interface IManagedEc2EcsComputeEnvironment extends IManagedComputeEnvironment {
+    /**
+     * Configure which AMIs this Compute Environment can launch.
+     *
+     * Leave this `undefined` to allow Batch to choose the latest AMIs it supports for each instance that it launches.
+     *
+     * @default
+     * - ECS_AL2 compatible AMI ids for non-GPU instances, ECS_AL2_NVIDIA compatible AMI ids for GPU instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, ECS_AL2023 will be used instead of ECS_AL2.
+     */
+    readonly images?: EcsMachineImage[];
+    /**
+     * The allocation strategy to use if not enough instances of
+     * the best fitting instance type can be allocated.
+     *
+     * @default - `BEST_FIT_PROGRESSIVE` if not using Spot instances,
+     * `SPOT_PRICE_CAPACITY_OPTIMIZED` if using Spot instances.
+     */
+    readonly allocationStrategy?: AllocationStrategy;
+    /**
+     * The maximum percentage that a Spot Instance price can be when compared with the
+     * On-Demand price for that instance type before instances are launched.
+     * For example, if your maximum percentage is 20%, the Spot price must be
+     * less than 20% of the current On-Demand price for that Instance.
+     * You always pay the lowest market price and never more than your maximum percentage.
+     * For most use cases, Batch recommends leaving this field empty.
+     *
+     * @default - 100%
+     */
+    readonly spotBidPercentage?: number;
+    /**
+     * The service-linked role that Spot Fleet needs to launch instances on your behalf.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html
+     *
+     * @default - a new Role will be created
+     */
+    readonly spotFleetRole?: iam.IRole;
+    /**
+     * The instance types that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     */
+    readonly instanceTypes: ec2.InstanceType[];
+    /**
+     * The instance classes that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     * Batch will automatically choose the size.
+     */
+    readonly instanceClasses: ec2.InstanceClass[];
+    /**
+     * Whether or not to use batch's optimal instance type.
+     * The optimal instance type is equivalent to adding the
+     * C4, M4, and R4 instance classes. You can specify other instance classes
+     * (of the same architecture) in addition to the optimal instance classes.
+     *
+     * @default true
+     */
+    readonly useOptimalInstanceClasses?: boolean;
+    /**
+     * The execution Role that instances launched by this Compute Environment will use.
+     *
+     * @default - a role will be created
+     */
+    readonly instanceRole?: iam.IRole;
+    /**
+     * The Launch Template that this Compute Environment
+     * will use to provision EC2 Instances.
+     *
+     * *Note*: if `securityGroups` is specified on both your
+     * launch template and this Compute Environment, **the
+     * `securityGroup`s on the Compute Environment override the
+     * ones on the launch template.
+     *
+     * @default no launch template
+     */
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    /**
+     * The minimum vCPUs that an environment should maintain,
+     * even if the compute environment is DISABLED.
+     *
+     * @default 0
+     */
+    readonly minvCpus?: number;
+    /**
+     * The EC2 placement group to associate with your compute resources.
+     * If you intend to submit multi-node parallel jobs to this Compute Environment,
+     * you should consider creating a cluster placement group and associate it with your compute resources.
+     * This keeps your multi-node parallel job on a logical grouping of instances
+     * within a single Availability Zone with high network flow potential.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
+     *
+     * @default - no placement group
+     */
+    readonly placementGroup?: ec2.IPlacementGroup;
+    /**
+     * Add an instance type to this compute environment
+     */
+    addInstanceType(instanceType: ec2.InstanceType): void;
+    /**
+     * Add an instance class to this compute environment
+     */
+    addInstanceClass(instanceClass: ec2.InstanceClass): void;
+}
+/**
+ * Base interface for containing all information needed to
+ * configure a MachineImage in Batch
+ */
+interface MachineImage {
+    /**
+     * The machine image to use
+     *
+     * @default - chosen by batch
+     */
+    readonly image?: ec2.IMachineImage;
+}
+/**
+ * A Batch MachineImage that is compatible with ECS
+ */
+export interface EcsMachineImage extends MachineImage {
+    /**
+     * Tells Batch which instance type to launch this image on
+     *
+     * @default - 'ECS_AL2' for non-gpu instances, 'ECS_AL2_NVIDIA' for gpu instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, 'ECS_AL2023' will be used instead of 'ECS_AL2'.
+     */
+    readonly imageType?: EcsMachineImageType;
+}
+/**
+ * A Batch MachineImage that is compatible with EKS
+ */
+export interface EksMachineImage extends MachineImage {
+    /**
+     * Tells Batch which instance type to launch this image on
+     *
+     * @default - 'EKS_AL2' for non-gpu instances, 'EKS_AL2_NVIDIA' for gpu instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, 'EKS_AL2023' will be used instead of 'EKS_AL2'.
+     */
+    readonly imageType?: EksMachineImageType;
+}
+/**
+ * Maps the image to instance types
+ */
+export declare enum EcsMachineImageType {
+    /**
+     * Tells Batch that this machine image runs on non-GPU AL2 instances
+     */
+    ECS_AL2 = "ECS_AL2",
+    /**
+     * Tells Batch that this machine image runs on non-GPU AL2023 instances.
+     * Amazon Linux 2023 does not support A1 instances.
+     */
+    ECS_AL2023 = "ECS_AL2023",
+    /**
+     * Tells Batch that this machine image runs on GPU instances
+     */
+    ECS_AL2_NVIDIA = "ECS_AL2_NVIDIA",
+    /**
+     * Tells Batch that this machine image runs on GPU AL2023 instances
+     */
+    ECS_AL2023_NVIDIA = "ECS_AL2023_NVIDIA"
+}
+/**
+ * Maps the image to instance types
+ */
+export declare enum EksMachineImageType {
+    /**
+     * Tells Batch that this machine image runs on non-GPU instances
+     */
+    EKS_AL2 = "EKS_AL2",
+    /**
+     * Tells Batch that this machine image runs on GPU instances
+     */
+    EKS_AL2_NVIDIA = "EKS_AL2_NVIDIA",
+    /**
+     * Tells Batch that this machine image runs on non-GPU AL2023 instances
+     */
+    EKS_AL2023 = "EKS_AL2023",
+    /**
+     * Tells Batch that this machine image runs on GPU AL2023 instances
+     */
+    EKS_AL2023_NVIDIA = "EKS_AL2023_NVIDIA"
+}
+/**
+ * Determines how this compute environment chooses instances to spawn
+ *
+ * @see https://aws.amazon.com/blogs/compute/optimizing-for-cost-availability-and-throughput-by-selecting-your-aws-batch-allocation-strategy/
+ */
+export declare enum AllocationStrategy {
+    /**
+     * Batch chooses the lowest-cost instance type that fits all the jobs in the queue.
+     * If instances of that type are not available, the queue will not choose a new type;
+     * instead, it will wait for the instance to become available.
+     * This can stall your `Queue`, with your compute environment only using part of its max capacity
+     * (or none at all) until the `BEST_FIT` instance becomes available.
+     * This allocation strategy keeps costs lower but can limit scaling.
+     * `BEST_FIT` isn't supported when updating compute environments
+     */
+    BEST_FIT = "BEST_FIT",
+    /**
+     * This is the default Allocation Strategy if `spot` is `false` or unspecified.
+     * This strategy will examine the Jobs in the queue and choose whichever instance type meets the requirements
+     * of the jobs in the queue and with the lowest cost per vCPU, just as `BEST_FIT`.
+     * However, if not all of the capacity can be filled with this instance type,
+     * it will choose a new next-best instance type to run any jobs that couldn’t fit into the `BEST_FIT` capacity.
+     * To make the most use of this allocation strategy,
+     * it is recommended to use as many instance classes as is feasible for your workload.
+     */
+    BEST_FIT_PROGRESSIVE = "BEST_FIT_PROGRESSIVE",
+    /**
+     * If your workflow tolerates interruptions, you should enable `spot` on your `ComputeEnvironment`
+     * and use `SPOT_CAPACITY_OPTIMIZED`.
+     * This will tell Batch to choose the instance types from the ones you've specified that have
+     * the most spot capacity available to minimize the chance of interruption.
+     * To get the most benefit from your spot instances,
+     * you should allow Batch to choose from as many different instance types as possible.
+     */
+    SPOT_CAPACITY_OPTIMIZED = "SPOT_CAPACITY_OPTIMIZED",
+    /**
+     * The price and capacity optimized allocation strategy looks at both price and capacity
+     * to select the Spot Instance pools that are the least likely to be interrupted
+     * and have the lowest possible price.
+     *
+     * The Batch team recommends this over `SPOT_CAPACITY_OPTIMIZED` in most instances.
+     */
+    SPOT_PRICE_CAPACITY_OPTIMIZED = "SPOT_PRICE_CAPACITY_OPTIMIZED"
+}
+/**
+ * Batch default instances types
+ *
+ * @see https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+ */
+export declare enum DefaultInstanceClass {
+    /**
+     * x86 based instance types (from the m6i, c6i, r6i, and c7i instance families)
+     */
+    X86_64 = "default_x86_64",
+    /**
+     * ARM64 based instance types (from the m6g, c6g, r6g, and c7g instance families)
+     */
+    ARM64 = "default_arm64"
+}
+/**
+ * Props for a ManagedEc2ComputeEnvironment
+ */
+export interface ManagedEc2ComputeEnvironmentProps extends ManagedComputeEnvironmentProps {
+    /**
+     * The instance types that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     *
+     * @default - the instances Batch considers will be used (currently C4, M4, and R4)
+     */
+    readonly instanceTypes?: ec2.InstanceType[];
+    /**
+     * The instance classes that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     * Batch will automatically choose the instance size.
+     *
+     * @default - the instances Batch considers will be used (currently C4, M4, and R4)
+     */
+    readonly instanceClasses?: ec2.InstanceClass[];
+}
+/**
+ * Props for a ManagedEc2EcsComputeEnvironment
+ */
+export interface ManagedEc2EcsComputeEnvironmentProps extends ManagedEc2ComputeEnvironmentProps {
+    /**
+     * Use batch's default instance types.
+     * A simpler way to choose up-to-date instance classes based on region
+     * instead of specifying exact instance classes.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+     * @default - choose from instanceTypes and instanceClasses
+     */
+    readonly defaultInstanceClasses?: DefaultInstanceClass[];
+    /**
+     * Whether or not to use batch's optimal instance type.
+     * The optimal instance type is equivalent to adding the
+     * C4, M4, and R4 instance classes. You can specify other instance classes
+     * (of the same architecture) in addition to the optimal instance classes.
+     *
+     * @default true
+     */
+    readonly useOptimalInstanceClasses?: boolean;
+    /**
+     * Configure which AMIs this Compute Environment can launch.
+     * If you specify this property with only `image` specified, then the
+     * `imageType` will default to `ECS_AL2` (or `ECS_AL2023` if the
+     * `@aws-cdk/aws-batch:defaultToAL2023` feature flag is set).
+     * *If your image needs GPU resources,
+     * specify `ECS_AL2_NVIDIA` or `ECS_AL2023_NVIDIA`; otherwise, the instances
+     * will not be able to properly join the ComputeEnvironment*.
+     *
+     * @default
+     * - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, ECS_AL2023 will be used instead of ECS_AL2.
+     */
+    readonly images?: EcsMachineImage[];
+    /**
+     * The allocation strategy to use if not enough instances of
+     * the best fitting instance type can be allocated.
+     *
+     * @default - `BEST_FIT_PROGRESSIVE` if not using Spot instances,
+     * `SPOT_PRICE_CAPACITY_OPTIMIZED` if using Spot instances.
+     */
+    readonly allocationStrategy?: AllocationStrategy;
+    /**
+     * The maximum percentage that a Spot Instance price can be when compared with the
+     * On-Demand price for that instance type before instances are launched.
+     * For example, if your maximum percentage is 20%, the Spot price must be
+     * less than 20% of the current On-Demand price for that Instance.
+     * You always pay the lowest market price and never more than your maximum percentage.
+     * For most use cases, Batch recommends leaving this field empty.
+     *
+     * Implies `spot == true` if set
+     *
+     * @default 100%
+     */
+    readonly spotBidPercentage?: number;
+    /**
+     * The service-linked role that Spot Fleet needs to launch instances on your behalf.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html
+     *
+     * @default - a new role will be created
+     */
+    readonly spotFleetRole?: iam.IRole;
+    /**
+     * The execution Role that instances launched by this Compute Environment will use.
+     *
+     * @default - a role will be created
+     */
+    readonly instanceRole?: iam.IRole;
+    /**
+     * The Launch Template that this Compute Environment
+     * will use to provision EC2 Instances.
+     *
+     * *Note*: if `securityGroups` is specified on both your
+     * launch template and this Compute Environment, **the
+     * `securityGroup`s on the Compute Environment override the
+     * ones on the launch template.
+     *
+     * @default no launch template
+     */
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    /**
+     * The minimum vCPUs that an environment should maintain,
+     * even if the compute environment is DISABLED.
+     *
+     * @default 0
+     */
+    readonly minvCpus?: number;
+    /**
+     * The EC2 placement group to associate with your compute resources.
+     * If you intend to submit multi-node parallel jobs to this Compute Environment,
+     * you should consider creating a cluster placement group and associate it with your compute resources.
+     * This keeps your multi-node parallel job on a logical grouping of instances
+     * within a single Availability Zone with high network flow potential.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
+     *
+     * @default - no placement group
+     */
+    readonly placementGroup?: ec2.IPlacementGroupRef;
+}
+/**
+ * A ManagedComputeEnvironment that uses EC2 instances.
+ */
+interface IManagedEc2ComputeEnvironment extends IManagedComputeEnvironment {
+    /**
+     * The instance types that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     */
+    readonly instanceTypes: ec2.InstanceType[];
+    /**
+     * The instance classes that this Compute Environment can launch.
+     * Which one is chosen depends on the `AllocationStrategy` used.
+     */
+    readonly instanceClasses: ec2.InstanceClass[];
+    /**
+     * Add an instance type to this compute environment
+     */
+    addInstanceType(instanceType: ec2.InstanceType): void;
+    /**
+     * Add an instance class to this compute environment
+     */
+    addInstanceClass(instanceClass: ec2.InstanceClass): void;
+}
+/**
+ * A ManagedComputeEnvironment that uses EC2 instances.
+ *
+ */
+declare abstract class ManagedEc2ComputeEnvironment extends ManagedComputeEnvironmentBase implements IManagedEc2ComputeEnvironment {
+    readonly instanceTypes: ec2.InstanceType[];
+    readonly instanceClasses: ec2.InstanceClass[];
+    constructor(scope: Construct, id: string, props: ManagedEc2ComputeEnvironmentProps);
+    addInstanceType(instanceType: ec2.InstanceType): void;
+    addInstanceClass(instanceClass: ec2.InstanceClass): void;
+}
+/**
+ * A ManagedComputeEnvironment that uses ECS orchestration on EC2 instances.
+ *
+ * @resource AWS::Batch::ComputeEnvironment
+ */
+export declare class ManagedEc2EcsComputeEnvironment extends ManagedEc2ComputeEnvironment implements IManagedEc2EcsComputeEnvironment {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * refer to an existing ComputeEnvironment by its arn.
+     */
+    static fromManagedEc2EcsComputeEnvironmentArn(scope: Construct, id: string, managedEc2EcsComputeEnvironmentArn: string): IManagedEc2EcsComputeEnvironment;
+    private readonly resource;
+    get computeEnvironmentArn(): string;
+    get computeEnvironmentName(): string;
+    readonly images?: EcsMachineImage[];
+    readonly allocationStrategy?: AllocationStrategy;
+    readonly spotBidPercentage?: number;
+    readonly spotFleetRole?: iam.IRole;
+    readonly instanceRole?: iam.IRole;
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    readonly minvCpus?: number;
+    private readonly _placementGroup?;
+    private readonly instanceProfile;
+    constructor(scope: Construct, id: string, props: ManagedEc2EcsComputeEnvironmentProps);
+    get placementGroup(): ec2.IPlacementGroup | undefined;
+}
+/**
+ * A ManagedComputeEnvironment that uses EKS orchestration on EC2 instances.
+ */
+interface IManagedEc2EksComputeEnvironment extends IManagedEc2ComputeEnvironment {
+    /**
+     * The namespace of the Cluster
+     *
+     * Cannot be 'default', start with 'kube-', or be longer than 64 characters.
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
+     */
+    readonly kubernetesNamespace?: string;
+    /**
+     * The cluster that backs this Compute Environment. Required
+     * for Compute Environments running Kubernetes jobs.
+     *
+     * Please ensure that you have followed the steps at
+     *
+     * https://docs.aws.amazon.com/batch/latest/userguide/getting-started-eks.html
+     *
+     * before attempting to deploy a `ManagedEc2EksComputeEnvironment` that uses this cluster.
+     * If you do not follow the steps in the link, the deployment fail with a message that the
+     * compute environment did not stabilize.
+     */
+    readonly eksCluster: eks.ICluster;
+    /**
+     * Configure which AMIs this Compute Environment can launch.
+     *
+     * @default
+     * EKS_AL2 for non-GPU instances, EKS_AL2_NVIDIA for GPU instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, EKS_AL2023 will be used instead of EKS_AL2.
+     */
+    readonly images?: EksMachineImage[];
+    /**
+     * The allocation strategy to use if not enough instances of
+     * the best fitting instance type can be allocated.
+     *
+     * @default - `BEST_FIT_PROGRESSIVE` if not using Spot instances,
+     * `SPOT_PRICE_CAPACITY_OPTIMIZED` if using Spot instances.
+     */
+    readonly allocationStrategy?: AllocationStrategy;
+    /**
+     * The maximum percentage that a Spot Instance price can be when compared with the
+     * On-Demand price for that instance type before instances are launched.
+     * For example, if your maximum percentage is 20%, the Spot price must be
+     * less than 20% of the current On-Demand price for that Instance.
+     * You always pay the lowest market price and never more than your maximum percentage.
+     * For most use cases, Batch recommends leaving this field empty.
+     *
+     * Implies `spot == true` if set
+     *
+     * @default - 100%
+     */
+    readonly spotBidPercentage?: number;
+    /**
+     * The execution Role that instances launched by this Compute Environment will use.
+     *
+     * @default - a role will be created
+     */
+    readonly instanceRole?: iam.IRole;
+    /**
+     * The Launch Template that this Compute Environment
+     * will use to provision EC2 Instances.
+     *
+     * *Note*: if `securityGroups` is specified on both your
+     * launch template and this Compute Environment, **the
+     * `securityGroup`s on the Compute Environment override the
+     * ones on the launch template.
+     *
+     * @default - no launch template
+     */
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    /**
+     * The minimum vCPUs that an environment should maintain,
+     * even if the compute environment is DISABLED.
+     *
+     * @default 0
+     */
+    readonly minvCpus?: number;
+    /**
+     * The EC2 placement group to associate with your compute resources.
+     * If you intend to submit multi-node parallel jobs to this Compute Environment,
+     * you should consider creating a cluster placement group and associate it with your compute resources.
+     * This keeps your multi-node parallel job on a logical grouping of instances
+     * within a single Availability Zone with high network flow potential.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
+     *
+     * @default - no placement group
+     */
+    readonly placementGroup?: ec2.IPlacementGroup;
+}
+/**
+ * Props for a ManagedEc2EksComputeEnvironment
+ */
+export interface ManagedEc2EksComputeEnvironmentProps extends ManagedEc2ComputeEnvironmentProps {
+    /**
+     * The namespace of the Cluster
+     */
+    readonly kubernetesNamespace: string;
+    /**
+     * The cluster that backs this Compute Environment. Required
+     * for Compute Environments running Kubernetes jobs.
+     *
+     * Please ensure that you have followed the steps at
+     *
+     * https://docs.aws.amazon.com/batch/latest/userguide/getting-started-eks.html
+     *
+     * before attempting to deploy a `ManagedEc2EksComputeEnvironment` that uses this cluster.
+     * If you do not follow the steps in the link, the deployment fail with a message that the
+     * compute environment did not stabilize.
+     */
+    readonly eksCluster: eks.ICluster;
+    /**
+     * Use batch's default instance types.
+     * A simpler way to choose up-to-date instance classes based on region
+     * instead of specifying exact instance classes.
+     *
+     * @see https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+     * @default - choose from instanceTypes and instanceClasses
+     */
+    readonly defaultInstanceClasses?: DefaultInstanceClass[];
+    /**
+     * Whether or not to use batch's optimal instance type.
+     * The optimal instance type is equivalent to adding the
+     * C4, M4, and R4 instance classes. You can specify other instance classes
+     * (of the same architecture) in addition to the optimal instance classes.
+     *
+     * @default true
+     */
+    readonly useOptimalInstanceClasses?: boolean;
+    /**
+     * Configure which AMIs this Compute Environment can launch.
+     *
+     * @default
+     * If `imageKubernetesVersion` is specified,
+     * - EKS_AL2 for non-GPU instances, EKS_AL2_NVIDIA for GPU instances.
+     * Otherwise,
+     * - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances.
+     * If the '@aws-cdk/aws-batch:defaultToAL2023' feature flag is set, EKS_AL2023 / ECS_AL2023 will be used instead.
+     */
+    readonly images?: EksMachineImage[];
+    /**
+     * The allocation strategy to use if not enough instances of
+     * the best fitting instance type can be allocated.
+     *
+     * @default - `BEST_FIT_PROGRESSIVE` if not using Spot instances,
+     * `SPOT_PRICE_CAPACITY_OPTIMIZED` if using Spot instances.
+     */
+    readonly allocationStrategy?: AllocationStrategy;
+    /**
+     * The maximum percentage that a Spot Instance price can be when compared with the
+     * On-Demand price for that instance type before instances are launched.
+     * For example, if your maximum percentage is 20%, the Spot price must be
+     * less than 20% of the current On-Demand price for that Instance.
+     * You always pay the lowest market price and never more than your maximum percentage.
+     * For most use cases, Batch recommends leaving this field empty.
+     *
+     * Implies `spot == true` if set
+     *
+     * @default - 100%
+     */
+    readonly spotBidPercentage?: number;
+    /**
+     * The execution Role that instances launched by this Compute Environment will use.
+     *
+     * @default - a role will be created
+     */
+    readonly instanceRole?: iam.IRole;
+    /**
+     * The Launch Template that this Compute Environment
+     * will use to provision EC2 Instances.
+     *
+     * *Note*: if `securityGroups` is specified on both your
+     * launch template and this Compute Environment, **the
+     * `securityGroup`s on the Compute Environment override the
+     * ones on the launch template.**
+     *
+     * @default - no launch template
+     */
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    /**
+     * The minimum vCPUs that an environment should maintain,
+     * even if the compute environment is DISABLED.
+     *
+     * @default 0
+     */
+    readonly minvCpus?: number;
+    /**
+     * The EC2 placement group to associate with your compute resources.
+     * If you intend to submit multi-node parallel jobs to this Compute Environment,
+     * you should consider creating a cluster placement group and associate it with your compute resources.
+     * This keeps your multi-node parallel job on a logical grouping of instances
+     * within a single Availability Zone with high network flow potential.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
+     *
+     * @default - no placement group
+     */
+    readonly placementGroup?: ec2.IPlacementGroupRef;
+}
+/**
+ * A ManagedComputeEnvironment that uses ECS orchestration on EC2 instances.
+ *
+ * @resource AWS::Batch::ComputeEnvironment
+ */
+export declare class ManagedEc2EksComputeEnvironment extends ManagedEc2ComputeEnvironment implements IManagedEc2EksComputeEnvironment {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly kubernetesNamespace?: string;
+    readonly eksCluster: eks.ICluster;
+    private readonly resource;
+    get computeEnvironmentName(): string;
+    get computeEnvironmentArn(): string;
+    readonly images?: EksMachineImage[];
+    readonly allocationStrategy?: AllocationStrategy;
+    readonly spotBidPercentage?: number;
+    readonly instanceRole?: iam.IRole;
+    readonly launchTemplate?: ec2.ILaunchTemplate;
+    readonly minvCpus?: number;
+    private readonly _placementGroup?;
+    private readonly instanceProfile;
+    constructor(scope: Construct, id: string, props: ManagedEc2EksComputeEnvironmentProps);
+    get placementGroup(): ec2.IPlacementGroup | undefined;
+}
+/**
+ * A ManagedComputeEnvironment that uses ECS orchestration on Fargate instances.
+ */
+export interface IFargateComputeEnvironment extends IManagedComputeEnvironment {
+}
+/**
+ * Props for a FargateComputeEnvironment
+ */
+export interface FargateComputeEnvironmentProps extends ManagedComputeEnvironmentProps {
+}
+/**
+ * A ManagedComputeEnvironment that uses ECS orchestration on Fargate instances.
+ *
+ * @resource AWS::Batch::ComputeEnvironment
+ */
+export declare class FargateComputeEnvironment extends ManagedComputeEnvironmentBase implements IFargateComputeEnvironment {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Reference an existing FargateComputeEnvironment by its arn
+     */
+    static fromFargateComputeEnvironmentArn(scope: Construct, id: string, fargateComputeEnvironmentArn: string): IFargateComputeEnvironment;
+    private readonly resource;
+    get computeEnvironmentName(): string;
+    get computeEnvironmentArn(): string;
+    constructor(scope: Construct, id: string, props: FargateComputeEnvironmentProps);
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-batch/lib/multinode-job-definition.d.ts

@@ -0,0 +1,128 @@
+import type { Construct } from 'constructs';
+import type { IEcsContainerDefinition } from './ecs-container-definition';
+import type { IJobDefinition, JobDefinitionProps } from './job-definition-base';
+import { JobDefinitionBase } from './job-definition-base';
+import * as ec2 from '../../aws-ec2';
+/**
+ * Not a real instance type! Indicates that Batch will choose one it determines to be optimal
+ * for the workload.
+ */
+export declare class OptimalInstanceType extends ec2.InstanceType {
+    constructor();
+}
+interface IMultiNodeJobDefinition extends IJobDefinition {
+    /**
+     * The containers that this multinode job will run.
+     *
+     * @see https://aws.amazon.com/blogs/compute/building-a-tightly-coupled-molecular-dynamics-workflow-with-multi-node-parallel-jobs-in-aws-batch/
+     */
+    readonly containers: MultiNodeContainer[];
+    /**
+     * The instance type that this job definition will run
+     *
+     * @default - optimal instance, selected by Batch
+     */
+    readonly instanceType?: ec2.InstanceType;
+    /**
+     * The index of the main node in this job.
+     * The main node is responsible for orchestration.
+     *
+     * @default 0
+     */
+    readonly mainNode?: number;
+    /**
+     * Whether to propagate tags from the JobDefinition
+     * to the ECS task that Batch spawns
+     *
+     * @default false
+     */
+    readonly propagateTags?: boolean;
+    /**
+     * Add a container to this multinode job
+     */
+    addContainer(container: MultiNodeContainer): void;
+}
+/**
+ * Runs the container on nodes [startNode, endNode]
+ */
+export interface MultiNodeContainer {
+    /**
+     * The index of the first node to run this container
+     *
+     * The container is run on all nodes in the range [startNode, endNode] (inclusive)
+     */
+    readonly startNode: number;
+    /**
+     * The index of the last node to run this container.
+     *
+     * The container is run on all nodes in the range [startNode, endNode] (inclusive)
+     */
+    readonly endNode: number;
+    /**
+     * The container that this node range will run
+     */
+    readonly container: IEcsContainerDefinition;
+}
+/**
+ * Props to configure a MultiNodeJobDefinition
+ */
+export interface MultiNodeJobDefinitionProps extends JobDefinitionProps {
+    /**
+     * The instance type that this job definition
+     * will run.
+     *
+     * @default - optimal instance, selected by Batch
+     */
+    readonly instanceType?: ec2.InstanceType;
+    /**
+     * The containers that this multinode job will run.
+     *
+     * @see https://aws.amazon.com/blogs/compute/building-a-tightly-coupled-molecular-dynamics-workflow-with-multi-node-parallel-jobs-in-aws-batch/
+     *
+     * @default none
+     */
+    readonly containers?: MultiNodeContainer[];
+    /**
+     * The index of the main node in this job.
+     * The main node is responsible for orchestration.
+     *
+     * @default 0
+     */
+    readonly mainNode?: number;
+    /**
+     * Whether to propagate tags from the JobDefinition
+     * to the ECS task that Batch spawns
+     *
+     * @default false
+     */
+    readonly propagateTags?: boolean;
+}
+/**
+ * A JobDefinition that uses Ecs orchestration to run multiple containers
+ *
+ * @resource AWS::Batch::JobDefinition
+ */
+export declare class MultiNodeJobDefinition extends JobDefinitionBase implements IMultiNodeJobDefinition {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * refer to an existing JobDefinition by its arn
+     */
+    static fromJobDefinitionArn(scope: Construct, id: string, jobDefinitionArn: string): IJobDefinition;
+    readonly mainNode?: number;
+    readonly propagateTags?: boolean;
+    private readonly resource;
+    private _containers;
+    get containers(): MultiNodeContainer[];
+    get jobDefinitionArn(): string;
+    get jobDefinitionName(): string;
+    private readonly _instanceType?;
+    constructor(scope: Construct, id: string, props?: MultiNodeJobDefinitionProps);
+    /**
+     * If the prop `instanceType` is left `undefined`, then this
+     * will hold a fake instance type, for backwards compatibility reasons.
+     */
+    get instanceType(): ec2.InstanceType;
+    addContainer(container: MultiNodeContainer): void;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-batch/lib/private/ref-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ISchedulingPolicyRef } from '../../../interfaces/generated/aws-batch-interfaces.generated';
+import type { ISchedulingPolicy } from '../scheduling-policy';
+/**
+ * Converts an ISchedulingPolicyRef to ISchedulingPolicy, validating that it implements the full interface.
+ */
+export declare function toISchedulingPolicy(policy: ISchedulingPolicyRef): ISchedulingPolicy;

cdk/node_modules/aws-cdk-lib/aws-batch/lib/private/ref-utils.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.toISchedulingPolicy=toISchedulingPolicy;var core_1=()=>{var tmp=require("../../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};function toISchedulingPolicy(policy){if(!("schedulingPolicyArn"in policy)||!("schedulingPolicyName"in policy))throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`SchedulingPolicyInstanceImplementScheduling`,`'schedulingPolicy' instance should implement ISchedulingPolicy, but doesn't: ${policy.constructor.name}`);return policy}

cdk/node_modules/aws-cdk-lib/aws-batch/lib/scheduling-policy.d.ts

@@ -0,0 +1,195 @@
+import type { Construct } from 'constructs';
+import type { Duration, IResource } from '../../core';
+import { Resource } from '../../core';
+import type { ISchedulingPolicyRef, SchedulingPolicyReference } from '../../interfaces/generated/aws-batch-interfaces.generated';
+/**
+ * Represents a Scheduling Policy. Scheduling Policies tell the Batch
+ * Job Scheduler how to schedule incoming jobs.
+ */
+export interface ISchedulingPolicy extends IResource, ISchedulingPolicyRef {
+    /**
+     * The name of this scheduling policy
+     *
+     * @attribute
+     */
+    readonly schedulingPolicyName: string;
+    /**
+     * The arn of this scheduling policy
+     *
+     * @attribute
+     */
+    readonly schedulingPolicyArn: string;
+}
+/**
+ * Props to configure a SchedulingPolicy
+ */
+interface SchedulingPolicyProps {
+    /**
+     * The name of this SchedulingPolicy
+     *
+     * @default - generated by CloudFormation
+     */
+    readonly schedulingPolicyName?: string;
+}
+/**
+ * @internal
+ */
+export declare abstract class SchedulingPolicyBase extends Resource implements ISchedulingPolicy {
+    abstract readonly schedulingPolicyName: string;
+    abstract readonly schedulingPolicyArn: string;
+    get schedulingPolicyRef(): SchedulingPolicyReference;
+    constructor(scope: Construct, id: string, props?: SchedulingPolicyProps);
+}
+/**
+ * Represents a group of Job Definitions. All Job Definitions that
+ * declare a share identifier will be considered members of the Share
+ * defined by that share identifier.
+ *
+ * The Scheduler divides the maximum available vCPUs of the ComputeEnvironment
+ * among Jobs in the Queue based on their shareIdentifier and the weightFactor
+ * associated with that shareIdentifier.
+ */
+export interface Share {
+    /**
+     * The identifier of this Share. All jobs that specify this share identifier
+     * when submitted to the queue will be considered as part of this Share.
+     */
+    readonly shareIdentifier: string;
+    /**
+     * The weight factor given to this Share. The Scheduler decides which jobs to put in the Compute Environment
+     * such that the following ratio is equal for each job:
+     *
+     * `sharevCpu / weightFactor`,
+     *
+     * where `sharevCpu` is the total amount of vCPU given to that particular share; that is,
+     * the sum of the vCPU of each job currently in the Compute Environment for that share.
+     *
+     * See the readme of this module for a detailed example that shows how these are used,
+     * how it relates to `computeReservation`, and how `shareDecay` affects these calculations.
+     */
+    readonly weightFactor: number;
+}
+/**
+ * Represents a Fairshare Scheduling Policy. Instructs the scheduler
+ * to allocate ComputeEnvironment vCPUs based on Job shareIdentifiers.
+ *
+ * The Faireshare Scheduling Policy ensures that each share gets a certain amount of vCPUs.
+ * It does this by deciding how many Jobs of each share to schedule *relative to how many jobs of
+ * each share are currently being executed by the ComputeEnvironment*. The weight factors associated with
+ * each share determine the ratio of vCPUs allocated; see the readme for a more in-depth discussion of
+ * fairshare policies.
+ */
+export interface IFairshareSchedulingPolicy extends ISchedulingPolicy {
+    /**
+     * Used to calculate the percentage of the maximum available vCPU to reserve for share identifiers not present in the Queue.
+     *
+     * The percentage reserved is defined by the Scheduler as:
+     * `(computeReservation/100)^ActiveFairShares` where `ActiveFairShares` is the number of active fair share identifiers.
+     *
+     * For example, a computeReservation value of 50 indicates that AWS Batch reserves 50% of the
+     * maximum available vCPU if there's only one fair share identifier.
+     * It reserves 25% if there are two fair share identifiers.
+     * It reserves 12.5% if there are three fair share identifiers.
+     *
+     * A computeReservation value of 25 indicates that AWS Batch should reserve 25% of the
+     * maximum available vCPU if there's only one fair share identifier,
+     * 6.25% if there are two fair share identifiers,
+     * and 1.56% if there are three fair share identifiers.
+     *
+     * @default - no vCPU is reserved
+     */
+    readonly computeReservation?: number;
+    /**
+     * The amount of time to use to measure the usage of each job.
+     * The usage is used to calculate a fair share percentage for each fair share identifier currently in the Queue.
+     * A value of zero (0) indicates that only current usage is measured.
+     * The decay is linear and gives preference to newer jobs.
+     *
+     * The maximum supported value is 604800 seconds (1 week).
+     *
+     * @default - 0: only the current job usage is considered
+     */
+    readonly shareDecay?: Duration;
+    /**
+     * The shares that this Scheduling Policy applies to.
+     * *Note*: It is possible to submit Jobs to the queue with Share Identifiers that
+     * are not recognized by the Scheduling Policy.
+     */
+    readonly shares: Share[];
+}
+/**
+ * Fairshare SchedulingPolicy configuration
+ */
+export interface FairshareSchedulingPolicyProps extends SchedulingPolicyProps {
+    /**
+     * Used to calculate the percentage of the maximum available vCPU to reserve for share identifiers not present in the Queue.
+     *
+     * The percentage reserved is defined by the Scheduler as:
+     * `(computeReservation/100)^ActiveFairShares` where `ActiveFairShares` is the number of active fair share identifiers.
+     *
+     * For example, a computeReservation value of 50 indicates that AWS Batch reserves 50% of the
+     * maximum available vCPU if there's only one fair share identifier.
+     * It reserves 25% if there are two fair share identifiers.
+     * It reserves 12.5% if there are three fair share identifiers.
+     *
+     * A computeReservation value of 25 indicates that AWS Batch should reserve 25% of the
+     * maximum available vCPU if there's only one fair share identifier,
+     * 6.25% if there are two fair share identifiers,
+     * and 1.56% if there are three fair share identifiers.
+     *
+     * @default - no vCPU is reserved
+     */
+    readonly computeReservation?: number;
+    /**
+     * The amount of time to use to measure the usage of each job.
+     * The usage is used to calculate a fair share percentage for each fair share identifier currently in the Queue.
+     * A value of zero (0) indicates that only current usage is measured.
+     * The decay is linear and gives preference to newer jobs.
+     *
+     * The maximum supported value is 604800 seconds (1 week).
+     *
+     * @default - 0: only the current job usage is considered
+     */
+    readonly shareDecay?: Duration;
+    /**
+     * The shares that this Scheduling Policy applies to.
+     * *Note*: It is possible to submit Jobs to the queue with Share Identifiers that
+     * are not recognized by the Scheduling Policy.
+     *
+     * @default - no shares
+     */
+    readonly shares?: Share[];
+}
+/**
+ * Represents a Fairshare Scheduling Policy. Instructs the scheduler
+ * to allocate ComputeEnvironment vCPUs based on Job shareIdentifiers.
+ *
+ * The Faireshare Scheduling Policy ensures that each share gets a certain amount of vCPUs.
+ * The scheduler does this by deciding how many Jobs of each share to schedule *relative to how many jobs of
+ * each share are currently being executed by the ComputeEnvironment*. The weight factors associated with
+ * each share determine the ratio of vCPUs allocated; see the readme for a more in-depth discussion of
+ * fairshare policies.
+ *
+ * @resource AWS::Batch::SchedulingPolicy
+ */
+export declare class FairshareSchedulingPolicy extends SchedulingPolicyBase implements IFairshareSchedulingPolicy {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Reference an existing Scheduling Policy by its ARN
+     */
+    static fromFairshareSchedulingPolicyArn(scope: Construct, id: string, fairshareSchedulingPolicyArn: string): IFairshareSchedulingPolicy;
+    readonly computeReservation?: number;
+    readonly shareDecay?: Duration;
+    private readonly _shares;
+    private readonly resource;
+    get schedulingPolicyArn(): string;
+    get shares(): Share[];
+    get schedulingPolicyName(): string;
+    constructor(scope: Construct, id: string, props?: FairshareSchedulingPolicyProps);
+    /**
+     * Add a share this to this Fairshare SchedulingPolicy
+     */
+    addShare(share: Share): void;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-batch/lib/unmanaged-compute-environment.d.ts

@@ -0,0 +1,51 @@
+import type { Construct } from 'constructs';
+import type { IComputeEnvironment, ComputeEnvironmentProps } from './compute-environment-base';
+import { ComputeEnvironmentBase } from './compute-environment-base';
+/**
+ * Represents an UnmanagedComputeEnvironment. Batch will not provision instances on your behalf
+ * in this ComputeEvironment.
+ */
+export interface IUnmanagedComputeEnvironment extends IComputeEnvironment {
+    /**
+     * The vCPUs this Compute Environment provides. Used only by the
+     * scheduler to schedule jobs in `Queue`s that use `FairshareSchedulingPolicy`s.
+     *
+     * **If this parameter is not provided on a fairshare queue, no capacity is reserved**;
+     * that is, the `FairshareSchedulingPolicy` is ignored.
+     */
+    readonly unmanagedvCPUs?: number;
+}
+/**
+ * Represents an UnmanagedComputeEnvironment. Batch will not provision instances on your behalf
+ * in this ComputeEvironment.
+ */
+export interface UnmanagedComputeEnvironmentProps extends ComputeEnvironmentProps {
+    /**
+     * The vCPUs this Compute Environment provides. Used only by the
+     * scheduler to schedule jobs in `Queue`s that use `FairshareSchedulingPolicy`s.
+     *
+     * **If this parameter is not provided on a fairshare queue, no capacity is reserved**;
+     * that is, the `FairshareSchedulingPolicy` is ignored.
+     *
+     * @default 0
+     */
+    readonly unmanagedvCpus?: number;
+}
+/**
+ * Unmanaged ComputeEnvironments do not provision or manage EC2 instances on your behalf.
+ *
+ * @resource AWS::Batch::ComputeEnvironment
+ */
+export declare class UnmanagedComputeEnvironment extends ComputeEnvironmentBase implements IUnmanagedComputeEnvironment {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an UnmanagedComputeEnvironment by its arn
+     */
+    static fromUnmanagedComputeEnvironmentArn(scope: Construct, id: string, unmanagedComputeEnvironmentArn: string): IUnmanagedComputeEnvironment;
+    readonly unmanagedvCPUs?: number | undefined;
+    private readonly resource;
+    get computeEnvironmentArn(): string;
+    get computeEnvironmentName(): string;
+    constructor(scope: Construct, id: string, props?: UnmanagedComputeEnvironmentProps);
+}