@aws-sdk/client-batch 3.50.0 → 3.53.0

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

@@ -0,0 +1,1530 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { BatchServiceException as __BaseException } from "./BatchServiceException";
+export declare enum ArrayJobDependency {
+    N_TO_N = "N_TO_N",
+    SEQUENTIAL = "SEQUENTIAL"
+}
+
+export interface ArrayProperties {
+    
+    size?: number;
+}
+export declare namespace ArrayProperties {
+    
+    const filterSensitiveLog: (obj: ArrayProperties) => any;
+}
+
+export interface ArrayPropertiesDetail {
+    
+    statusSummary?: {
+        [key: string]: number;
+    };
+    
+    size?: number;
+    
+    index?: number;
+}
+export declare namespace ArrayPropertiesDetail {
+    
+    const filterSensitiveLog: (obj: ArrayPropertiesDetail) => any;
+}
+
+export interface ArrayPropertiesSummary {
+    
+    size?: number;
+    
+    index?: number;
+}
+export declare namespace ArrayPropertiesSummary {
+    
+    const filterSensitiveLog: (obj: ArrayPropertiesSummary) => any;
+}
+export declare enum AssignPublicIp {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface NetworkInterface {
+    
+    attachmentId?: string;
+    
+    ipv6Address?: string;
+    
+    privateIpv4Address?: string;
+}
+export declare namespace NetworkInterface {
+    
+    const filterSensitiveLog: (obj: NetworkInterface) => any;
+}
+
+export interface AttemptContainerDetail {
+    
+    containerInstanceArn?: string;
+    
+    taskArn?: string;
+    
+    exitCode?: number;
+    
+    reason?: string;
+    
+    logStreamName?: string;
+    
+    networkInterfaces?: NetworkInterface[];
+}
+export declare namespace AttemptContainerDetail {
+    
+    const filterSensitiveLog: (obj: AttemptContainerDetail) => any;
+}
+
+export interface AttemptDetail {
+    
+    container?: AttemptContainerDetail;
+    
+    startedAt?: number;
+    
+    stoppedAt?: number;
+    
+    statusReason?: string;
+}
+export declare namespace AttemptDetail {
+    
+    const filterSensitiveLog: (obj: AttemptDetail) => any;
+}
+
+export interface CancelJobRequest {
+    
+    jobId: string | undefined;
+    
+    reason: string | undefined;
+}
+export declare namespace CancelJobRequest {
+    
+    const filterSensitiveLog: (obj: CancelJobRequest) => any;
+}
+export interface CancelJobResponse {
+}
+export declare namespace CancelJobResponse {
+    
+    const filterSensitiveLog: (obj: CancelJobResponse) => any;
+}
+
+export declare class ClientException extends __BaseException {
+    readonly name: "ClientException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClientException, __BaseException>);
+}
+
+export declare class ServerException extends __BaseException {
+    readonly name: "ServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServerException, __BaseException>);
+}
+export declare enum CRAllocationStrategy {
+    BEST_FIT = "BEST_FIT",
+    BEST_FIT_PROGRESSIVE = "BEST_FIT_PROGRESSIVE",
+    SPOT_CAPACITY_OPTIMIZED = "SPOT_CAPACITY_OPTIMIZED"
+}
+
+export interface Ec2Configuration {
+    
+    imageType: string | undefined;
+    
+    imageIdOverride?: string;
+}
+export declare namespace Ec2Configuration {
+    
+    const filterSensitiveLog: (obj: Ec2Configuration) => any;
+}
+
+export interface LaunchTemplateSpecification {
+    
+    launchTemplateId?: string;
+    
+    launchTemplateName?: string;
+    
+    version?: string;
+}
+export declare namespace LaunchTemplateSpecification {
+    
+    const filterSensitiveLog: (obj: LaunchTemplateSpecification) => any;
+}
+export declare enum CRType {
+    EC2 = "EC2",
+    FARGATE = "FARGATE",
+    FARGATE_SPOT = "FARGATE_SPOT",
+    SPOT = "SPOT"
+}
+
+export interface ComputeResource {
+    
+    type: CRType | string | undefined;
+    
+    allocationStrategy?: CRAllocationStrategy | string;
+    
+    minvCpus?: number;
+    
+    maxvCpus: number | undefined;
+    
+    desiredvCpus?: number;
+    
+    instanceTypes?: string[];
+    
+    imageId?: string;
+    
+    subnets: string[] | undefined;
+    
+    securityGroupIds?: string[];
+    
+    ec2KeyPair?: string;
+    
+    instanceRole?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    placementGroup?: string;
+    
+    bidPercentage?: number;
+    
+    spotIamFleetRole?: string;
+    
+    launchTemplate?: LaunchTemplateSpecification;
+    
+    ec2Configuration?: Ec2Configuration[];
+}
+export declare namespace ComputeResource {
+    
+    const filterSensitiveLog: (obj: ComputeResource) => any;
+}
+export declare enum CEState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum CEType {
+    MANAGED = "MANAGED",
+    UNMANAGED = "UNMANAGED"
+}
+
+export interface CreateComputeEnvironmentRequest {
+    
+    computeEnvironmentName: string | undefined;
+    
+    type: CEType | string | undefined;
+    
+    state?: CEState | string;
+    
+    unmanagedvCpus?: number;
+    
+    computeResources?: ComputeResource;
+    
+    serviceRole?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateComputeEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateComputeEnvironmentRequest) => any;
+}
+export interface CreateComputeEnvironmentResponse {
+    
+    computeEnvironmentName?: string;
+    
+    computeEnvironmentArn?: string;
+}
+export declare namespace CreateComputeEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateComputeEnvironmentResponse) => any;
+}
+
+export interface ComputeEnvironmentOrder {
+    
+    order: number | undefined;
+    
+    computeEnvironment: string | undefined;
+}
+export declare namespace ComputeEnvironmentOrder {
+    
+    const filterSensitiveLog: (obj: ComputeEnvironmentOrder) => any;
+}
+export declare enum JQState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface CreateJobQueueRequest {
+    
+    jobQueueName: string | undefined;
+    
+    state?: JQState | string;
+    
+    schedulingPolicyArn?: string;
+    
+    priority: number | undefined;
+    
+    computeEnvironmentOrder: ComputeEnvironmentOrder[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateJobQueueRequest {
+    
+    const filterSensitiveLog: (obj: CreateJobQueueRequest) => any;
+}
+export interface CreateJobQueueResponse {
+    
+    jobQueueName: string | undefined;
+    
+    jobQueueArn: string | undefined;
+}
+export declare namespace CreateJobQueueResponse {
+    
+    const filterSensitiveLog: (obj: CreateJobQueueResponse) => any;
+}
+
+export interface ShareAttributes {
+    
+    shareIdentifier: string | undefined;
+    
+    weightFactor?: number;
+}
+export declare namespace ShareAttributes {
+    
+    const filterSensitiveLog: (obj: ShareAttributes) => any;
+}
+
+export interface FairsharePolicy {
+    
+    shareDecaySeconds?: number;
+    
+    computeReservation?: number;
+    
+    shareDistribution?: ShareAttributes[];
+}
+export declare namespace FairsharePolicy {
+    
+    const filterSensitiveLog: (obj: FairsharePolicy) => any;
+}
+export interface CreateSchedulingPolicyRequest {
+    
+    name: string | undefined;
+    
+    fairsharePolicy?: FairsharePolicy;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSchedulingPolicyRequest {
+    
+    const filterSensitiveLog: (obj: CreateSchedulingPolicyRequest) => any;
+}
+export interface CreateSchedulingPolicyResponse {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+}
+export declare namespace CreateSchedulingPolicyResponse {
+    
+    const filterSensitiveLog: (obj: CreateSchedulingPolicyResponse) => any;
+}
+
+export interface DeleteComputeEnvironmentRequest {
+    
+    computeEnvironment: string | undefined;
+}
+export declare namespace DeleteComputeEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteComputeEnvironmentRequest) => any;
+}
+export interface DeleteComputeEnvironmentResponse {
+}
+export declare namespace DeleteComputeEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteComputeEnvironmentResponse) => any;
+}
+
+export interface DeleteJobQueueRequest {
+    
+    jobQueue: string | undefined;
+}
+export declare namespace DeleteJobQueueRequest {
+    
+    const filterSensitiveLog: (obj: DeleteJobQueueRequest) => any;
+}
+export interface DeleteJobQueueResponse {
+}
+export declare namespace DeleteJobQueueResponse {
+    
+    const filterSensitiveLog: (obj: DeleteJobQueueResponse) => any;
+}
+export interface DeleteSchedulingPolicyRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteSchedulingPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSchedulingPolicyRequest) => any;
+}
+export interface DeleteSchedulingPolicyResponse {
+}
+export declare namespace DeleteSchedulingPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSchedulingPolicyResponse) => any;
+}
+export interface DeregisterJobDefinitionRequest {
+    
+    jobDefinition: string | undefined;
+}
+export declare namespace DeregisterJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterJobDefinitionRequest) => any;
+}
+export interface DeregisterJobDefinitionResponse {
+}
+export declare namespace DeregisterJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterJobDefinitionResponse) => any;
+}
+
+export interface DescribeComputeEnvironmentsRequest {
+    
+    computeEnvironments?: string[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeComputeEnvironmentsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeComputeEnvironmentsRequest) => any;
+}
+export declare enum CEStatus {
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    INVALID = "INVALID",
+    UPDATING = "UPDATING",
+    VALID = "VALID"
+}
+
+export interface ComputeEnvironmentDetail {
+    
+    computeEnvironmentName: string | undefined;
+    
+    computeEnvironmentArn: string | undefined;
+    
+    unmanagedvCpus?: number;
+    
+    ecsClusterArn: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    type?: CEType | string;
+    
+    state?: CEState | string;
+    
+    status?: CEStatus | string;
+    
+    statusReason?: string;
+    
+    computeResources?: ComputeResource;
+    
+    serviceRole?: string;
+}
+export declare namespace ComputeEnvironmentDetail {
+    
+    const filterSensitiveLog: (obj: ComputeEnvironmentDetail) => any;
+}
+export interface DescribeComputeEnvironmentsResponse {
+    
+    computeEnvironments?: ComputeEnvironmentDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeComputeEnvironmentsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeComputeEnvironmentsResponse) => any;
+}
+
+export interface DescribeJobDefinitionsRequest {
+    
+    jobDefinitions?: string[];
+    
+    maxResults?: number;
+    
+    jobDefinitionName?: string;
+    
+    status?: string;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobDefinitionsRequest) => any;
+}
+
+export interface KeyValuePair {
+    
+    name?: string;
+    
+    value?: string;
+}
+export declare namespace KeyValuePair {
+    
+    const filterSensitiveLog: (obj: KeyValuePair) => any;
+}
+
+export interface FargatePlatformConfiguration {
+    
+    platformVersion?: string;
+}
+export declare namespace FargatePlatformConfiguration {
+    
+    const filterSensitiveLog: (obj: FargatePlatformConfiguration) => any;
+}
+export declare enum DeviceCgroupPermission {
+    MKNOD = "MKNOD",
+    READ = "READ",
+    WRITE = "WRITE"
+}
+
+export interface Device {
+    
+    hostPath: string | undefined;
+    
+    containerPath?: string;
+    
+    permissions?: (DeviceCgroupPermission | string)[];
+}
+export declare namespace Device {
+    
+    const filterSensitiveLog: (obj: Device) => any;
+}
+
+export interface Tmpfs {
+    
+    containerPath: string | undefined;
+    
+    size: number | undefined;
+    
+    mountOptions?: string[];
+}
+export declare namespace Tmpfs {
+    
+    const filterSensitiveLog: (obj: Tmpfs) => any;
+}
+
+export interface LinuxParameters {
+    
+    devices?: Device[];
+    
+    initProcessEnabled?: boolean;
+    
+    sharedMemorySize?: number;
+    
+    tmpfs?: Tmpfs[];
+    
+    maxSwap?: number;
+    
+    swappiness?: number;
+}
+export declare namespace LinuxParameters {
+    
+    const filterSensitiveLog: (obj: LinuxParameters) => any;
+}
+export declare enum LogDriver {
+    AWSLOGS = "awslogs",
+    FLUENTD = "fluentd",
+    GELF = "gelf",
+    JOURNALD = "journald",
+    JSON_FILE = "json-file",
+    SPLUNK = "splunk",
+    SYSLOG = "syslog"
+}
+
+export interface Secret {
+    
+    name: string | undefined;
+    
+    valueFrom: string | undefined;
+}
+export declare namespace Secret {
+    
+    const filterSensitiveLog: (obj: Secret) => any;
+}
+
+export interface LogConfiguration {
+    
+    logDriver: LogDriver | string | undefined;
+    
+    options?: {
+        [key: string]: string;
+    };
+    
+    secretOptions?: Secret[];
+}
+export declare namespace LogConfiguration {
+    
+    const filterSensitiveLog: (obj: LogConfiguration) => any;
+}
+
+export interface MountPoint {
+    
+    containerPath?: string;
+    
+    readOnly?: boolean;
+    
+    sourceVolume?: string;
+}
+export declare namespace MountPoint {
+    
+    const filterSensitiveLog: (obj: MountPoint) => any;
+}
+
+export interface NetworkConfiguration {
+    
+    assignPublicIp?: AssignPublicIp | string;
+}
+export declare namespace NetworkConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkConfiguration) => any;
+}
+export declare enum ResourceType {
+    GPU = "GPU",
+    MEMORY = "MEMORY",
+    VCPU = "VCPU"
+}
+
+export interface ResourceRequirement {
+    
+    value: string | undefined;
+    
+    type: ResourceType | string | undefined;
+}
+export declare namespace ResourceRequirement {
+    
+    const filterSensitiveLog: (obj: ResourceRequirement) => any;
+}
+
+export interface Ulimit {
+    
+    hardLimit: number | undefined;
+    
+    name: string | undefined;
+    
+    softLimit: number | undefined;
+}
+export declare namespace Ulimit {
+    
+    const filterSensitiveLog: (obj: Ulimit) => any;
+}
+export declare enum EFSAuthorizationConfigIAM {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface EFSAuthorizationConfig {
+    
+    accessPointId?: string;
+    
+    iam?: EFSAuthorizationConfigIAM | string;
+}
+export declare namespace EFSAuthorizationConfig {
+    
+    const filterSensitiveLog: (obj: EFSAuthorizationConfig) => any;
+}
+export declare enum EFSTransitEncryption {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface EFSVolumeConfiguration {
+    
+    fileSystemId: string | undefined;
+    
+    rootDirectory?: string;
+    
+    transitEncryption?: EFSTransitEncryption | string;
+    
+    transitEncryptionPort?: number;
+    
+    authorizationConfig?: EFSAuthorizationConfig;
+}
+export declare namespace EFSVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: EFSVolumeConfiguration) => any;
+}
+
+export interface Host {
+    
+    sourcePath?: string;
+}
+export declare namespace Host {
+    
+    const filterSensitiveLog: (obj: Host) => any;
+}
+
+export interface Volume {
+    
+    host?: Host;
+    
+    name?: string;
+    
+    efsVolumeConfiguration?: EFSVolumeConfiguration;
+}
+export declare namespace Volume {
+    
+    const filterSensitiveLog: (obj: Volume) => any;
+}
+
+export interface ContainerProperties {
+    
+    image?: string;
+    
+    vcpus?: number;
+    
+    memory?: number;
+    
+    command?: string[];
+    
+    jobRoleArn?: string;
+    
+    executionRoleArn?: string;
+    
+    volumes?: Volume[];
+    
+    environment?: KeyValuePair[];
+    
+    mountPoints?: MountPoint[];
+    
+    readonlyRootFilesystem?: boolean;
+    
+    privileged?: boolean;
+    
+    ulimits?: Ulimit[];
+    
+    user?: string;
+    
+    instanceType?: string;
+    
+    resourceRequirements?: ResourceRequirement[];
+    
+    linuxParameters?: LinuxParameters;
+    
+    logConfiguration?: LogConfiguration;
+    
+    secrets?: Secret[];
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    fargatePlatformConfiguration?: FargatePlatformConfiguration;
+}
+export declare namespace ContainerProperties {
+    
+    const filterSensitiveLog: (obj: ContainerProperties) => any;
+}
+
+export interface NodeRangeProperty {
+    
+    targetNodes: string | undefined;
+    
+    container?: ContainerProperties;
+}
+export declare namespace NodeRangeProperty {
+    
+    const filterSensitiveLog: (obj: NodeRangeProperty) => any;
+}
+
+export interface NodeProperties {
+    
+    numNodes: number | undefined;
+    
+    mainNode: number | undefined;
+    
+    nodeRangeProperties: NodeRangeProperty[] | undefined;
+}
+export declare namespace NodeProperties {
+    
+    const filterSensitiveLog: (obj: NodeProperties) => any;
+}
+export declare enum PlatformCapability {
+    EC2 = "EC2",
+    FARGATE = "FARGATE"
+}
+export declare enum RetryAction {
+    EXIT = "EXIT",
+    RETRY = "RETRY"
+}
+
+export interface EvaluateOnExit {
+    
+    onStatusReason?: string;
+    
+    onReason?: string;
+    
+    onExitCode?: string;
+    
+    action: RetryAction | string | undefined;
+}
+export declare namespace EvaluateOnExit {
+    
+    const filterSensitiveLog: (obj: EvaluateOnExit) => any;
+}
+
+export interface RetryStrategy {
+    
+    attempts?: number;
+    
+    evaluateOnExit?: EvaluateOnExit[];
+}
+export declare namespace RetryStrategy {
+    
+    const filterSensitiveLog: (obj: RetryStrategy) => any;
+}
+
+export interface JobTimeout {
+    
+    attemptDurationSeconds?: number;
+}
+export declare namespace JobTimeout {
+    
+    const filterSensitiveLog: (obj: JobTimeout) => any;
+}
+
+export interface JobDefinition {
+    
+    jobDefinitionName: string | undefined;
+    
+    jobDefinitionArn: string | undefined;
+    
+    revision: number | undefined;
+    
+    status?: string;
+    
+    type: string | undefined;
+    
+    schedulingPriority?: number;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    retryStrategy?: RetryStrategy;
+    
+    containerProperties?: ContainerProperties;
+    
+    timeout?: JobTimeout;
+    
+    nodeProperties?: NodeProperties;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    propagateTags?: boolean;
+    
+    platformCapabilities?: (PlatformCapability | string)[];
+}
+export declare namespace JobDefinition {
+    
+    const filterSensitiveLog: (obj: JobDefinition) => any;
+}
+export interface DescribeJobDefinitionsResponse {
+    
+    jobDefinitions?: JobDefinition[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobDefinitionsResponse) => any;
+}
+
+export interface DescribeJobQueuesRequest {
+    
+    jobQueues?: string[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobQueuesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobQueuesRequest) => any;
+}
+export declare enum JQStatus {
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    INVALID = "INVALID",
+    UPDATING = "UPDATING",
+    VALID = "VALID"
+}
+
+export interface JobQueueDetail {
+    
+    jobQueueName: string | undefined;
+    
+    jobQueueArn: string | undefined;
+    
+    state: JQState | string | undefined;
+    
+    schedulingPolicyArn?: string;
+    
+    status?: JQStatus | string;
+    
+    statusReason?: string;
+    
+    priority: number | undefined;
+    
+    computeEnvironmentOrder: ComputeEnvironmentOrder[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace JobQueueDetail {
+    
+    const filterSensitiveLog: (obj: JobQueueDetail) => any;
+}
+export interface DescribeJobQueuesResponse {
+    
+    jobQueues?: JobQueueDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobQueuesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobQueuesResponse) => any;
+}
+
+export interface DescribeJobsRequest {
+    
+    jobs: string[] | undefined;
+}
+export declare namespace DescribeJobsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobsRequest) => any;
+}
+
+export interface ContainerDetail {
+    
+    image?: string;
+    
+    vcpus?: number;
+    
+    memory?: number;
+    
+    command?: string[];
+    
+    jobRoleArn?: string;
+    
+    executionRoleArn?: string;
+    
+    volumes?: Volume[];
+    
+    environment?: KeyValuePair[];
+    
+    mountPoints?: MountPoint[];
+    
+    readonlyRootFilesystem?: boolean;
+    
+    ulimits?: Ulimit[];
+    
+    privileged?: boolean;
+    
+    user?: string;
+    
+    exitCode?: number;
+    
+    reason?: string;
+    
+    containerInstanceArn?: string;
+    
+    taskArn?: string;
+    
+    logStreamName?: string;
+    
+    instanceType?: string;
+    
+    networkInterfaces?: NetworkInterface[];
+    
+    resourceRequirements?: ResourceRequirement[];
+    
+    linuxParameters?: LinuxParameters;
+    
+    logConfiguration?: LogConfiguration;
+    
+    secrets?: Secret[];
+    
+    networkConfiguration?: NetworkConfiguration;
+    
+    fargatePlatformConfiguration?: FargatePlatformConfiguration;
+}
+export declare namespace ContainerDetail {
+    
+    const filterSensitiveLog: (obj: ContainerDetail) => any;
+}
+
+export interface JobDependency {
+    
+    jobId?: string;
+    
+    type?: ArrayJobDependency | string;
+}
+export declare namespace JobDependency {
+    
+    const filterSensitiveLog: (obj: JobDependency) => any;
+}
+
+export interface NodeDetails {
+    
+    nodeIndex?: number;
+    
+    isMainNode?: boolean;
+}
+export declare namespace NodeDetails {
+    
+    const filterSensitiveLog: (obj: NodeDetails) => any;
+}
+export declare enum JobStatus {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNABLE = "RUNNABLE",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    SUBMITTED = "SUBMITTED",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface JobDetail {
+    
+    jobArn?: string;
+    
+    jobName: string | undefined;
+    
+    jobId: string | undefined;
+    
+    jobQueue: string | undefined;
+    
+    status: JobStatus | string | undefined;
+    
+    shareIdentifier?: string;
+    
+    schedulingPriority?: number;
+    
+    attempts?: AttemptDetail[];
+    
+    statusReason?: string;
+    
+    createdAt?: number;
+    
+    retryStrategy?: RetryStrategy;
+    
+    startedAt: number | undefined;
+    
+    stoppedAt?: number;
+    
+    dependsOn?: JobDependency[];
+    
+    jobDefinition: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    container?: ContainerDetail;
+    
+    nodeDetails?: NodeDetails;
+    
+    nodeProperties?: NodeProperties;
+    
+    arrayProperties?: ArrayPropertiesDetail;
+    
+    timeout?: JobTimeout;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    propagateTags?: boolean;
+    
+    platformCapabilities?: (PlatformCapability | string)[];
+}
+export declare namespace JobDetail {
+    
+    const filterSensitiveLog: (obj: JobDetail) => any;
+}
+export interface DescribeJobsResponse {
+    
+    jobs?: JobDetail[];
+}
+export declare namespace DescribeJobsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobsResponse) => any;
+}
+export interface DescribeSchedulingPoliciesRequest {
+    
+    arns: string[] | undefined;
+}
+export declare namespace DescribeSchedulingPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSchedulingPoliciesRequest) => any;
+}
+
+export interface SchedulingPolicyDetail {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    fairsharePolicy?: FairsharePolicy;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace SchedulingPolicyDetail {
+    
+    const filterSensitiveLog: (obj: SchedulingPolicyDetail) => any;
+}
+export interface DescribeSchedulingPoliciesResponse {
+    
+    schedulingPolicies?: SchedulingPolicyDetail[];
+}
+export declare namespace DescribeSchedulingPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSchedulingPoliciesResponse) => any;
+}
+
+export interface KeyValuesPair {
+    
+    name?: string;
+    
+    values?: string[];
+}
+export declare namespace KeyValuesPair {
+    
+    const filterSensitiveLog: (obj: KeyValuesPair) => any;
+}
+
+export interface ListJobsRequest {
+    
+    jobQueue?: string;
+    
+    arrayJobId?: string;
+    
+    multiNodeJobId?: string;
+    
+    jobStatus?: JobStatus | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    filters?: KeyValuesPair[];
+}
+export declare namespace ListJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListJobsRequest) => any;
+}
+
+export interface ContainerSummary {
+    
+    exitCode?: number;
+    
+    reason?: string;
+}
+export declare namespace ContainerSummary {
+    
+    const filterSensitiveLog: (obj: ContainerSummary) => any;
+}
+
+export interface NodePropertiesSummary {
+    
+    isMainNode?: boolean;
+    
+    numNodes?: number;
+    
+    nodeIndex?: number;
+}
+export declare namespace NodePropertiesSummary {
+    
+    const filterSensitiveLog: (obj: NodePropertiesSummary) => any;
+}
+
+export interface JobSummary {
+    
+    jobArn?: string;
+    
+    jobId: string | undefined;
+    
+    jobName: string | undefined;
+    
+    createdAt?: number;
+    
+    status?: JobStatus | string;
+    
+    statusReason?: string;
+    
+    startedAt?: number;
+    
+    stoppedAt?: number;
+    
+    container?: ContainerSummary;
+    
+    arrayProperties?: ArrayPropertiesSummary;
+    
+    nodeProperties?: NodePropertiesSummary;
+    
+    jobDefinition?: string;
+}
+export declare namespace JobSummary {
+    
+    const filterSensitiveLog: (obj: JobSummary) => any;
+}
+export interface ListJobsResponse {
+    
+    jobSummaryList: JobSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListJobsResponse) => any;
+}
+export interface ListSchedulingPoliciesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListSchedulingPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListSchedulingPoliciesRequest) => any;
+}
+
+export interface SchedulingPolicyListingDetail {
+    
+    arn: string | undefined;
+}
+export declare namespace SchedulingPolicyListingDetail {
+    
+    const filterSensitiveLog: (obj: SchedulingPolicyListingDetail) => any;
+}
+export interface ListSchedulingPoliciesResponse {
+    
+    schedulingPolicies?: SchedulingPolicyListingDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace ListSchedulingPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListSchedulingPoliciesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export declare enum JobDefinitionType {
+    Container = "container",
+    Multinode = "multinode"
+}
+
+export interface RegisterJobDefinitionRequest {
+    
+    jobDefinitionName: string | undefined;
+    
+    type: JobDefinitionType | string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    schedulingPriority?: number;
+    
+    containerProperties?: ContainerProperties;
+    
+    nodeProperties?: NodeProperties;
+    
+    retryStrategy?: RetryStrategy;
+    
+    propagateTags?: boolean;
+    
+    timeout?: JobTimeout;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    platformCapabilities?: (PlatformCapability | string)[];
+}
+export declare namespace RegisterJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: RegisterJobDefinitionRequest) => any;
+}
+export interface RegisterJobDefinitionResponse {
+    
+    jobDefinitionName: string | undefined;
+    
+    jobDefinitionArn: string | undefined;
+    
+    revision: number | undefined;
+}
+export declare namespace RegisterJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: RegisterJobDefinitionResponse) => any;
+}
+
+export interface ContainerOverrides {
+    
+    vcpus?: number;
+    
+    memory?: number;
+    
+    command?: string[];
+    
+    instanceType?: string;
+    
+    environment?: KeyValuePair[];
+    
+    resourceRequirements?: ResourceRequirement[];
+}
+export declare namespace ContainerOverrides {
+    
+    const filterSensitiveLog: (obj: ContainerOverrides) => any;
+}
+
+export interface NodePropertyOverride {
+    
+    targetNodes: string | undefined;
+    
+    containerOverrides?: ContainerOverrides;
+}
+export declare namespace NodePropertyOverride {
+    
+    const filterSensitiveLog: (obj: NodePropertyOverride) => any;
+}
+
+export interface NodeOverrides {
+    
+    numNodes?: number;
+    
+    nodePropertyOverrides?: NodePropertyOverride[];
+}
+export declare namespace NodeOverrides {
+    
+    const filterSensitiveLog: (obj: NodeOverrides) => any;
+}
+
+export interface SubmitJobRequest {
+    
+    jobName: string | undefined;
+    
+    jobQueue: string | undefined;
+    
+    shareIdentifier?: string;
+    
+    schedulingPriorityOverride?: number;
+    
+    arrayProperties?: ArrayProperties;
+    
+    dependsOn?: JobDependency[];
+    
+    jobDefinition: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    containerOverrides?: ContainerOverrides;
+    
+    nodeOverrides?: NodeOverrides;
+    
+    retryStrategy?: RetryStrategy;
+    
+    propagateTags?: boolean;
+    
+    timeout?: JobTimeout;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace SubmitJobRequest {
+    
+    const filterSensitiveLog: (obj: SubmitJobRequest) => any;
+}
+export interface SubmitJobResponse {
+    
+    jobArn?: string;
+    
+    jobName: string | undefined;
+    
+    jobId: string | undefined;
+}
+export declare namespace SubmitJobResponse {
+    
+    const filterSensitiveLog: (obj: SubmitJobResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export interface TerminateJobRequest {
+    
+    jobId: string | undefined;
+    
+    reason: string | undefined;
+}
+export declare namespace TerminateJobRequest {
+    
+    const filterSensitiveLog: (obj: TerminateJobRequest) => any;
+}
+export interface TerminateJobResponse {
+}
+export declare namespace TerminateJobResponse {
+    
+    const filterSensitiveLog: (obj: TerminateJobResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface ComputeResourceUpdate {
+    
+    minvCpus?: number;
+    
+    maxvCpus?: number;
+    
+    desiredvCpus?: number;
+    
+    subnets?: string[];
+    
+    securityGroupIds?: string[];
+}
+export declare namespace ComputeResourceUpdate {
+    
+    const filterSensitiveLog: (obj: ComputeResourceUpdate) => any;
+}
+
+export interface UpdateComputeEnvironmentRequest {
+    
+    computeEnvironment: string | undefined;
+    
+    state?: CEState | string;
+    
+    unmanagedvCpus?: number;
+    
+    computeResources?: ComputeResourceUpdate;
+    
+    serviceRole?: string;
+}
+export declare namespace UpdateComputeEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateComputeEnvironmentRequest) => any;
+}
+export interface UpdateComputeEnvironmentResponse {
+    
+    computeEnvironmentName?: string;
+    
+    computeEnvironmentArn?: string;
+}
+export declare namespace UpdateComputeEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateComputeEnvironmentResponse) => any;
+}
+
+export interface UpdateJobQueueRequest {
+    
+    jobQueue: string | undefined;
+    
+    state?: JQState | string;
+    
+    schedulingPolicyArn?: string;
+    
+    priority?: number;
+    
+    computeEnvironmentOrder?: ComputeEnvironmentOrder[];
+}
+export declare namespace UpdateJobQueueRequest {
+    
+    const filterSensitiveLog: (obj: UpdateJobQueueRequest) => any;
+}
+export interface UpdateJobQueueResponse {
+    
+    jobQueueName?: string;
+    
+    jobQueueArn?: string;
+}
+export declare namespace UpdateJobQueueResponse {
+    
+    const filterSensitiveLog: (obj: UpdateJobQueueResponse) => any;
+}
+export interface UpdateSchedulingPolicyRequest {
+    
+    arn: string | undefined;
+    
+    fairsharePolicy?: FairsharePolicy;
+}
+export declare namespace UpdateSchedulingPolicyRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSchedulingPolicyRequest) => any;
+}
+export interface UpdateSchedulingPolicyResponse {
+}
+export declare namespace UpdateSchedulingPolicyResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSchedulingPolicyResponse) => any;
+}