@aws-sdk/client-m2 3.107.0

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

@@ -0,0 +1,1609 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { M2ServiceException as __BaseException } from "./M2ServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface AlternateKey {
+    
+    name?: string;
+    
+    offset: number | undefined;
+    
+    length: number | undefined;
+    
+    allowDuplicates?: boolean;
+}
+export declare namespace AlternateKey {
+    
+    const filterSensitiveLog: (obj: AlternateKey) => any;
+}
+export interface CancelBatchJobExecutionRequest {
+    
+    applicationId: string | undefined;
+    
+    executionId: string | undefined;
+}
+export declare namespace CancelBatchJobExecutionRequest {
+    
+    const filterSensitiveLog: (obj: CancelBatchJobExecutionRequest) => any;
+}
+export interface CancelBatchJobExecutionResponse {
+}
+export declare namespace CancelBatchJobExecutionResponse {
+    
+    const filterSensitiveLog: (obj: CancelBatchJobExecutionResponse) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    $retryable: {};
+    
+    retryAfterSeconds?: number;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    $retryable: {
+        throttling: boolean;
+    };
+    
+    serviceCode?: string;
+    
+    quotaCode?: string;
+    
+    retryAfterSeconds?: number;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export interface ValidationExceptionField {
+    
+    name: string | undefined;
+    
+    message: string | undefined;
+}
+export declare namespace ValidationExceptionField {
+    
+    const filterSensitiveLog: (obj: ValidationExceptionField) => any;
+}
+export declare enum ValidationExceptionReason {
+    CANNOT_PARSE = "cannotParse",
+    FIELD_VALIDATION_FAILED = "fieldValidationFailed",
+    OTHER = "other",
+    UNKNOWN_OPERATION = "unknownOperation"
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    reason?: ValidationExceptionReason | string;
+    
+    fieldList?: ValidationExceptionField[];
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export declare type Definition = Definition.ContentMember | Definition.S3LocationMember | Definition.$UnknownMember;
+export declare namespace Definition {
+    
+    interface S3LocationMember {
+        s3Location: string;
+        content?: never;
+        $unknown?: never;
+    }
+    
+    interface ContentMember {
+        s3Location?: never;
+        content: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        s3Location?: never;
+        content?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        s3Location: (value: string) => T;
+        content: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Definition, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: Definition) => any;
+}
+export declare enum EngineType {
+    BLUAGE = "bluage",
+    MICROFOCUS = "microfocus"
+}
+export interface CreateApplicationRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    engineType: EngineType | string | undefined;
+    
+    definition: Definition | undefined;
+    
+    tags?: Record<string, string>;
+    
+    clientToken?: string;
+}
+export declare namespace CreateApplicationRequest {
+    
+    const filterSensitiveLog: (obj: CreateApplicationRequest) => any;
+}
+export interface CreateApplicationResponse {
+    
+    applicationArn: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    applicationVersion: number | undefined;
+}
+export declare namespace CreateApplicationResponse {
+    
+    const filterSensitiveLog: (obj: CreateApplicationResponse) => any;
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+    
+    serviceCode?: string;
+    
+    quotaCode?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export interface GdgAttributes {
+    
+    limit?: number;
+    
+    rollDisposition?: string;
+}
+export declare namespace GdgAttributes {
+    
+    const filterSensitiveLog: (obj: GdgAttributes) => any;
+}
+
+export interface PrimaryKey {
+    
+    name?: string;
+    
+    offset: number | undefined;
+    
+    length: number | undefined;
+}
+export declare namespace PrimaryKey {
+    
+    const filterSensitiveLog: (obj: PrimaryKey) => any;
+}
+
+export interface VsamAttributes {
+    
+    format: string | undefined;
+    
+    encoding?: string;
+    
+    compressed?: boolean;
+    
+    primaryKey?: PrimaryKey;
+    
+    alternateKeys?: AlternateKey[];
+}
+export declare namespace VsamAttributes {
+    
+    const filterSensitiveLog: (obj: VsamAttributes) => any;
+}
+
+export declare type DatasetOrgAttributes = DatasetOrgAttributes.GdgMember | DatasetOrgAttributes.VsamMember | DatasetOrgAttributes.$UnknownMember;
+export declare namespace DatasetOrgAttributes {
+    
+    interface VsamMember {
+        vsam: VsamAttributes;
+        gdg?: never;
+        $unknown?: never;
+    }
+    
+    interface GdgMember {
+        vsam?: never;
+        gdg: GdgAttributes;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        vsam?: never;
+        gdg?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        vsam: (value: VsamAttributes) => T;
+        gdg: (value: GdgAttributes) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: DatasetOrgAttributes, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: DatasetOrgAttributes) => any;
+}
+
+export interface RecordLength {
+    
+    min: number | undefined;
+    
+    max: number | undefined;
+}
+export declare namespace RecordLength {
+    
+    const filterSensitiveLog: (obj: RecordLength) => any;
+}
+
+export interface DataSet {
+    
+    storageType?: string;
+    
+    datasetName: string | undefined;
+    
+    datasetOrg: DatasetOrgAttributes | undefined;
+    
+    relativePath?: string;
+    
+    recordLength: RecordLength | undefined;
+}
+export declare namespace DataSet {
+    
+    const filterSensitiveLog: (obj: DataSet) => any;
+}
+
+export declare type ExternalLocation = ExternalLocation.S3LocationMember | ExternalLocation.$UnknownMember;
+export declare namespace ExternalLocation {
+    
+    interface S3LocationMember {
+        s3Location: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        s3Location?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        s3Location: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ExternalLocation, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ExternalLocation) => any;
+}
+
+export interface DataSetImportItem {
+    
+    dataSet: DataSet | undefined;
+    
+    externalLocation: ExternalLocation | undefined;
+}
+export declare namespace DataSetImportItem {
+    
+    const filterSensitiveLog: (obj: DataSetImportItem) => any;
+}
+
+export declare type DataSetImportConfig = DataSetImportConfig.DataSetsMember | DataSetImportConfig.S3LocationMember | DataSetImportConfig.$UnknownMember;
+export declare namespace DataSetImportConfig {
+    
+    interface S3LocationMember {
+        s3Location: string;
+        dataSets?: never;
+        $unknown?: never;
+    }
+    
+    interface DataSetsMember {
+        s3Location?: never;
+        dataSets: DataSetImportItem[];
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        s3Location?: never;
+        dataSets?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        s3Location: (value: string) => T;
+        dataSets: (value: DataSetImportItem[]) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: DataSetImportConfig, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: DataSetImportConfig) => any;
+}
+export interface CreateDataSetImportTaskRequest {
+    
+    applicationId: string | undefined;
+    
+    importConfig: DataSetImportConfig | undefined;
+    
+    clientToken?: string;
+}
+export declare namespace CreateDataSetImportTaskRequest {
+    
+    const filterSensitiveLog: (obj: CreateDataSetImportTaskRequest) => any;
+}
+export interface CreateDataSetImportTaskResponse {
+    
+    taskId: string | undefined;
+}
+export declare namespace CreateDataSetImportTaskResponse {
+    
+    const filterSensitiveLog: (obj: CreateDataSetImportTaskResponse) => any;
+}
+export interface CreateDeploymentRequest {
+    
+    environmentId: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    applicationVersion: number | undefined;
+    
+    clientToken?: string;
+}
+export declare namespace CreateDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentRequest) => any;
+}
+export interface CreateDeploymentResponse {
+    
+    deploymentId: string | undefined;
+}
+export declare namespace CreateDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentResponse) => any;
+}
+export interface DeleteApplicationRequest {
+    
+    applicationId: string | undefined;
+}
+export declare namespace DeleteApplicationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationRequest) => any;
+}
+export interface DeleteApplicationResponse {
+}
+export declare namespace DeleteApplicationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationResponse) => any;
+}
+export interface DeleteApplicationFromEnvironmentRequest {
+    
+    applicationId: string | undefined;
+    
+    environmentId: string | undefined;
+}
+export declare namespace DeleteApplicationFromEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationFromEnvironmentRequest) => any;
+}
+export interface DeleteApplicationFromEnvironmentResponse {
+}
+export declare namespace DeleteApplicationFromEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationFromEnvironmentResponse) => any;
+}
+export interface GetApplicationRequest {
+    
+    applicationId: string | undefined;
+}
+export declare namespace GetApplicationRequest {
+    
+    const filterSensitiveLog: (obj: GetApplicationRequest) => any;
+}
+export declare enum DeploymentLifecycle {
+    DEPLOYING = "Deploying",
+    FAILED = "Failed",
+    SUCCEEDED = "Succeeded"
+}
+
+export interface DeployedVersionSummary {
+    
+    applicationVersion: number | undefined;
+    
+    status: DeploymentLifecycle | string | undefined;
+    
+    statusReason?: string;
+}
+export declare namespace DeployedVersionSummary {
+    
+    const filterSensitiveLog: (obj: DeployedVersionSummary) => any;
+}
+export declare enum ApplicationVersionLifecycle {
+    AVAILABLE = "Available",
+    CREATING = "Creating",
+    FAILED = "Failed"
+}
+
+export interface ApplicationVersionSummary {
+    
+    applicationVersion: number | undefined;
+    
+    status: ApplicationVersionLifecycle | string | undefined;
+    
+    statusReason?: string;
+    
+    creationTime: Date | undefined;
+}
+export declare namespace ApplicationVersionSummary {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionSummary) => any;
+}
+
+export interface LogGroupSummary {
+    
+    logType: string | undefined;
+    
+    logGroupName: string | undefined;
+}
+export declare namespace LogGroupSummary {
+    
+    const filterSensitiveLog: (obj: LogGroupSummary) => any;
+}
+export declare enum ApplicationLifecycle {
+    AVAILABLE = "Available",
+    CREATED = "Created",
+    CREATING = "Creating",
+    DELETING = "Deleting",
+    FAILED = "Failed",
+    READY = "Ready",
+    RUNNING = "Running",
+    STARTING = "Starting",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+export interface GetApplicationResponse {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    applicationId: string | undefined;
+    
+    applicationArn: string | undefined;
+    
+    status: ApplicationLifecycle | string | undefined;
+    
+    latestVersion: ApplicationVersionSummary | undefined;
+    
+    deployedVersion?: DeployedVersionSummary;
+    
+    engineType: EngineType | string | undefined;
+    
+    logGroups?: LogGroupSummary[];
+    
+    creationTime: Date | undefined;
+    
+    lastStartTime?: Date;
+    
+    tags?: Record<string, string>;
+    
+    environmentId?: string;
+    
+    targetGroupArns?: string[];
+    
+    listenerArns?: string[];
+    
+    listenerPorts?: number[];
+    
+    loadBalancerDnsName?: string;
+    
+    statusReason?: string;
+}
+export declare namespace GetApplicationResponse {
+    
+    const filterSensitiveLog: (obj: GetApplicationResponse) => any;
+}
+export interface GetApplicationVersionRequest {
+    
+    applicationId: string | undefined;
+    
+    applicationVersion: number | undefined;
+}
+export declare namespace GetApplicationVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetApplicationVersionRequest) => any;
+}
+export interface GetApplicationVersionResponse {
+    
+    name: string | undefined;
+    
+    applicationVersion: number | undefined;
+    
+    description?: string;
+    
+    definitionContent: string | undefined;
+    
+    status: ApplicationVersionLifecycle | string | undefined;
+    
+    creationTime: Date | undefined;
+    
+    statusReason?: string;
+}
+export declare namespace GetApplicationVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetApplicationVersionResponse) => any;
+}
+export interface GetBatchJobExecutionRequest {
+    
+    applicationId: string | undefined;
+    
+    executionId: string | undefined;
+}
+export declare namespace GetBatchJobExecutionRequest {
+    
+    const filterSensitiveLog: (obj: GetBatchJobExecutionRequest) => any;
+}
+export declare enum BatchJobType {
+    JES2 = "JES2",
+    JES3 = "JES3",
+    VSE = "VSE"
+}
+export declare enum BatchJobExecutionStatus {
+    CANCELLED = "Cancelled",
+    CANCELLING = "Cancelling",
+    DISPATCH = "Dispatching",
+    FAILED = "Failed",
+    HOLDING = "Holding",
+    RUNNING = "Running",
+    SUBMITTING = "Submitting",
+    SUCCEEDED = "Succeeded",
+    SUCCEEDED_WITH_WARNING = "Succeeded With Warning"
+}
+export interface GetBatchJobExecutionResponse {
+    
+    executionId: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    jobId?: string;
+    
+    jobName?: string;
+    
+    jobUser?: string;
+    
+    jobType?: BatchJobType | string;
+    
+    status: BatchJobExecutionStatus | string | undefined;
+    
+    startTime: Date | undefined;
+    
+    endTime?: Date;
+    
+    statusReason?: string;
+}
+export declare namespace GetBatchJobExecutionResponse {
+    
+    const filterSensitiveLog: (obj: GetBatchJobExecutionResponse) => any;
+}
+export interface GetDataSetDetailsRequest {
+    
+    applicationId: string | undefined;
+    
+    dataSetName: string | undefined;
+}
+export declare namespace GetDataSetDetailsRequest {
+    
+    const filterSensitiveLog: (obj: GetDataSetDetailsRequest) => any;
+}
+
+export interface GdgDetailAttributes {
+    
+    limit?: number;
+    
+    rollDisposition?: string;
+}
+export declare namespace GdgDetailAttributes {
+    
+    const filterSensitiveLog: (obj: GdgDetailAttributes) => any;
+}
+
+export interface VsamDetailAttributes {
+    
+    encoding?: string;
+    
+    recordFormat?: string;
+    
+    compressed?: boolean;
+    
+    cacheAtStartup?: boolean;
+    
+    primaryKey?: PrimaryKey;
+    
+    alternateKeys?: AlternateKey[];
+}
+export declare namespace VsamDetailAttributes {
+    
+    const filterSensitiveLog: (obj: VsamDetailAttributes) => any;
+}
+
+export declare type DatasetDetailOrgAttributes = DatasetDetailOrgAttributes.GdgMember | DatasetDetailOrgAttributes.VsamMember | DatasetDetailOrgAttributes.$UnknownMember;
+export declare namespace DatasetDetailOrgAttributes {
+    
+    interface VsamMember {
+        vsam: VsamDetailAttributes;
+        gdg?: never;
+        $unknown?: never;
+    }
+    
+    interface GdgMember {
+        vsam?: never;
+        gdg: GdgDetailAttributes;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        vsam?: never;
+        gdg?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        vsam: (value: VsamDetailAttributes) => T;
+        gdg: (value: GdgDetailAttributes) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: DatasetDetailOrgAttributes, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: DatasetDetailOrgAttributes) => any;
+}
+export interface GetDataSetDetailsResponse {
+    
+    dataSetName: string | undefined;
+    
+    dataSetOrg?: DatasetDetailOrgAttributes;
+    
+    recordLength?: number;
+    
+    location?: string;
+    
+    blocksize?: number;
+    
+    creationTime?: Date;
+    
+    lastUpdatedTime?: Date;
+    
+    lastReferencedTime?: Date;
+}
+export declare namespace GetDataSetDetailsResponse {
+    
+    const filterSensitiveLog: (obj: GetDataSetDetailsResponse) => any;
+}
+export interface GetDataSetImportTaskRequest {
+    
+    applicationId: string | undefined;
+    
+    taskId: string | undefined;
+}
+export declare namespace GetDataSetImportTaskRequest {
+    
+    const filterSensitiveLog: (obj: GetDataSetImportTaskRequest) => any;
+}
+export declare enum DataSetTaskLifecycle {
+    COMPLETED = "Completed",
+    CREATING = "Creating",
+    RUNNING = "Running"
+}
+
+export interface DataSetImportSummary {
+    
+    total: number | undefined;
+    
+    succeeded: number | undefined;
+    
+    failed: number | undefined;
+    
+    pending: number | undefined;
+    
+    inProgress: number | undefined;
+}
+export declare namespace DataSetImportSummary {
+    
+    const filterSensitiveLog: (obj: DataSetImportSummary) => any;
+}
+export interface GetDataSetImportTaskResponse {
+    
+    taskId: string | undefined;
+    
+    status: DataSetTaskLifecycle | string | undefined;
+    
+    summary?: DataSetImportSummary;
+}
+export declare namespace GetDataSetImportTaskResponse {
+    
+    const filterSensitiveLog: (obj: GetDataSetImportTaskResponse) => any;
+}
+export interface GetDeploymentRequest {
+    
+    deploymentId: string | undefined;
+    
+    applicationId: string | undefined;
+}
+export declare namespace GetDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: GetDeploymentRequest) => any;
+}
+export interface GetDeploymentResponse {
+    
+    deploymentId: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    environmentId: string | undefined;
+    
+    applicationVersion: number | undefined;
+    
+    status: DeploymentLifecycle | string | undefined;
+    
+    creationTime: Date | undefined;
+    
+    statusReason?: string;
+}
+export declare namespace GetDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: GetDeploymentResponse) => any;
+}
+export interface ListApplicationsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    names?: string[];
+    
+    environmentId?: string;
+}
+export declare namespace ListApplicationsRequest {
+    
+    const filterSensitiveLog: (obj: ListApplicationsRequest) => any;
+}
+export declare enum ApplicationDeploymentLifecycle {
+    DEPLOYED = "Deployed",
+    DEPLOYING = "Deploying"
+}
+
+export interface ApplicationSummary {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    applicationId: string | undefined;
+    
+    applicationArn: string | undefined;
+    
+    applicationVersion: number | undefined;
+    
+    status: ApplicationLifecycle | string | undefined;
+    
+    engineType: EngineType | string | undefined;
+    
+    creationTime: Date | undefined;
+    
+    environmentId?: string;
+    
+    lastStartTime?: Date;
+    
+    versionStatus?: ApplicationVersionLifecycle | string;
+    
+    deploymentStatus?: ApplicationDeploymentLifecycle | string;
+}
+export declare namespace ApplicationSummary {
+    
+    const filterSensitiveLog: (obj: ApplicationSummary) => any;
+}
+export interface ListApplicationsResponse {
+    
+    applications: ApplicationSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationsResponse {
+    
+    const filterSensitiveLog: (obj: ListApplicationsResponse) => any;
+}
+export interface ListApplicationVersionsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    applicationId: string | undefined;
+}
+export declare namespace ListApplicationVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListApplicationVersionsRequest) => any;
+}
+export interface ListApplicationVersionsResponse {
+    
+    applicationVersions: ApplicationVersionSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListApplicationVersionsResponse) => any;
+}
+export interface ListBatchJobDefinitionsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    applicationId: string | undefined;
+    
+    prefix?: string;
+}
+export declare namespace ListBatchJobDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListBatchJobDefinitionsRequest) => any;
+}
+
+export interface FileBatchJobDefinition {
+    
+    fileName: string | undefined;
+    
+    folderPath?: string;
+}
+export declare namespace FileBatchJobDefinition {
+    
+    const filterSensitiveLog: (obj: FileBatchJobDefinition) => any;
+}
+
+export interface ScriptBatchJobDefinition {
+    
+    scriptName: string | undefined;
+}
+export declare namespace ScriptBatchJobDefinition {
+    
+    const filterSensitiveLog: (obj: ScriptBatchJobDefinition) => any;
+}
+
+export declare type BatchJobDefinition = BatchJobDefinition.FileBatchJobDefinitionMember | BatchJobDefinition.ScriptBatchJobDefinitionMember | BatchJobDefinition.$UnknownMember;
+export declare namespace BatchJobDefinition {
+    
+    interface FileBatchJobDefinitionMember {
+        fileBatchJobDefinition: FileBatchJobDefinition;
+        scriptBatchJobDefinition?: never;
+        $unknown?: never;
+    }
+    
+    interface ScriptBatchJobDefinitionMember {
+        fileBatchJobDefinition?: never;
+        scriptBatchJobDefinition: ScriptBatchJobDefinition;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        fileBatchJobDefinition?: never;
+        scriptBatchJobDefinition?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        fileBatchJobDefinition: (value: FileBatchJobDefinition) => T;
+        scriptBatchJobDefinition: (value: ScriptBatchJobDefinition) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: BatchJobDefinition, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: BatchJobDefinition) => any;
+}
+export interface ListBatchJobDefinitionsResponse {
+    
+    batchJobDefinitions: BatchJobDefinition[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListBatchJobDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListBatchJobDefinitionsResponse) => any;
+}
+export interface ListBatchJobExecutionsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    applicationId: string | undefined;
+    
+    executionIds?: string[];
+    
+    jobName?: string;
+    
+    status?: BatchJobExecutionStatus | string;
+    
+    startedAfter?: Date;
+    
+    startedBefore?: Date;
+}
+export declare namespace ListBatchJobExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: ListBatchJobExecutionsRequest) => any;
+}
+
+export interface BatchJobExecutionSummary {
+    
+    executionId: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    jobId?: string;
+    
+    jobName?: string;
+    
+    jobType?: BatchJobType | string;
+    
+    status: BatchJobExecutionStatus | string | undefined;
+    
+    startTime: Date | undefined;
+    
+    endTime?: Date;
+}
+export declare namespace BatchJobExecutionSummary {
+    
+    const filterSensitiveLog: (obj: BatchJobExecutionSummary) => any;
+}
+export interface ListBatchJobExecutionsResponse {
+    
+    batchJobExecutions: BatchJobExecutionSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListBatchJobExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: ListBatchJobExecutionsResponse) => any;
+}
+export interface ListDataSetImportHistoryRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    applicationId: string | undefined;
+}
+export declare namespace ListDataSetImportHistoryRequest {
+    
+    const filterSensitiveLog: (obj: ListDataSetImportHistoryRequest) => any;
+}
+
+export interface DataSetImportTask {
+    
+    taskId: string | undefined;
+    
+    status: DataSetTaskLifecycle | string | undefined;
+    
+    summary: DataSetImportSummary | undefined;
+}
+export declare namespace DataSetImportTask {
+    
+    const filterSensitiveLog: (obj: DataSetImportTask) => any;
+}
+export interface ListDataSetImportHistoryResponse {
+    
+    dataSetImportTasks: DataSetImportTask[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListDataSetImportHistoryResponse {
+    
+    const filterSensitiveLog: (obj: ListDataSetImportHistoryResponse) => any;
+}
+export interface ListDataSetsRequest {
+    
+    applicationId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    prefix?: string;
+}
+export declare namespace ListDataSetsRequest {
+    
+    const filterSensitiveLog: (obj: ListDataSetsRequest) => any;
+}
+
+export interface DataSetSummary {
+    
+    dataSetName: string | undefined;
+    
+    dataSetOrg?: string;
+    
+    format?: string;
+    
+    creationTime?: Date;
+    
+    lastUpdatedTime?: Date;
+    
+    lastReferencedTime?: Date;
+}
+export declare namespace DataSetSummary {
+    
+    const filterSensitiveLog: (obj: DataSetSummary) => any;
+}
+export interface ListDataSetsResponse {
+    
+    dataSets: DataSetSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListDataSetsResponse {
+    
+    const filterSensitiveLog: (obj: ListDataSetsResponse) => any;
+}
+export interface ListDeploymentsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    applicationId: string | undefined;
+}
+export declare namespace ListDeploymentsRequest {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsRequest) => any;
+}
+
+export interface DeploymentSummary {
+    
+    deploymentId: string | undefined;
+    
+    applicationId: string | undefined;
+    
+    environmentId: string | undefined;
+    
+    applicationVersion: number | undefined;
+    
+    status: DeploymentLifecycle | string | undefined;
+    
+    creationTime: Date | undefined;
+    
+    statusReason?: string;
+}
+export declare namespace DeploymentSummary {
+    
+    const filterSensitiveLog: (obj: DeploymentSummary) => any;
+}
+export interface ListDeploymentsResponse {
+    
+    deployments: DeploymentSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentsResponse {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsResponse) => any;
+}
+export interface StartApplicationRequest {
+    
+    applicationId: string | undefined;
+}
+export declare namespace StartApplicationRequest {
+    
+    const filterSensitiveLog: (obj: StartApplicationRequest) => any;
+}
+export interface StartApplicationResponse {
+}
+export declare namespace StartApplicationResponse {
+    
+    const filterSensitiveLog: (obj: StartApplicationResponse) => any;
+}
+
+export interface FileBatchJobIdentifier {
+    
+    fileName: string | undefined;
+    
+    folderPath?: string;
+}
+export declare namespace FileBatchJobIdentifier {
+    
+    const filterSensitiveLog: (obj: FileBatchJobIdentifier) => any;
+}
+
+export interface ScriptBatchJobIdentifier {
+    
+    scriptName: string | undefined;
+}
+export declare namespace ScriptBatchJobIdentifier {
+    
+    const filterSensitiveLog: (obj: ScriptBatchJobIdentifier) => any;
+}
+
+export declare type BatchJobIdentifier = BatchJobIdentifier.FileBatchJobIdentifierMember | BatchJobIdentifier.ScriptBatchJobIdentifierMember | BatchJobIdentifier.$UnknownMember;
+export declare namespace BatchJobIdentifier {
+    
+    interface FileBatchJobIdentifierMember {
+        fileBatchJobIdentifier: FileBatchJobIdentifier;
+        scriptBatchJobIdentifier?: never;
+        $unknown?: never;
+    }
+    
+    interface ScriptBatchJobIdentifierMember {
+        fileBatchJobIdentifier?: never;
+        scriptBatchJobIdentifier: ScriptBatchJobIdentifier;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        fileBatchJobIdentifier?: never;
+        scriptBatchJobIdentifier?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        fileBatchJobIdentifier: (value: FileBatchJobIdentifier) => T;
+        scriptBatchJobIdentifier: (value: ScriptBatchJobIdentifier) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: BatchJobIdentifier, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: BatchJobIdentifier) => any;
+}
+export interface StartBatchJobRequest {
+    
+    applicationId: string | undefined;
+    
+    batchJobIdentifier: BatchJobIdentifier | undefined;
+    
+    jobParams?: Record<string, string>;
+}
+export declare namespace StartBatchJobRequest {
+    
+    const filterSensitiveLog: (obj: StartBatchJobRequest) => any;
+}
+export interface StartBatchJobResponse {
+    
+    executionId: string | undefined;
+}
+export declare namespace StartBatchJobResponse {
+    
+    const filterSensitiveLog: (obj: StartBatchJobResponse) => any;
+}
+export interface StopApplicationRequest {
+    
+    applicationId: string | undefined;
+    
+    forceStop?: boolean;
+}
+export declare namespace StopApplicationRequest {
+    
+    const filterSensitiveLog: (obj: StopApplicationRequest) => any;
+}
+export interface StopApplicationResponse {
+}
+export declare namespace StopApplicationResponse {
+    
+    const filterSensitiveLog: (obj: StopApplicationResponse) => any;
+}
+export interface UpdateApplicationRequest {
+    
+    applicationId: string | undefined;
+    
+    description?: string;
+    
+    currentApplicationVersion: number | undefined;
+    
+    definition?: Definition;
+}
+export declare namespace UpdateApplicationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationRequest) => any;
+}
+export interface UpdateApplicationResponse {
+    
+    applicationVersion: number | undefined;
+}
+export declare namespace UpdateApplicationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationResponse) => any;
+}
+
+export interface HighAvailabilityConfig {
+    
+    desiredCapacity: number | undefined;
+}
+export declare namespace HighAvailabilityConfig {
+    
+    const filterSensitiveLog: (obj: HighAvailabilityConfig) => any;
+}
+
+export interface EfsStorageConfiguration {
+    
+    fileSystemId: string | undefined;
+    
+    mountPoint: string | undefined;
+}
+export declare namespace EfsStorageConfiguration {
+    
+    const filterSensitiveLog: (obj: EfsStorageConfiguration) => any;
+}
+
+export interface FsxStorageConfiguration {
+    
+    fileSystemId: string | undefined;
+    
+    mountPoint: string | undefined;
+}
+export declare namespace FsxStorageConfiguration {
+    
+    const filterSensitiveLog: (obj: FsxStorageConfiguration) => any;
+}
+
+export declare type StorageConfiguration = StorageConfiguration.EfsMember | StorageConfiguration.FsxMember | StorageConfiguration.$UnknownMember;
+export declare namespace StorageConfiguration {
+    
+    interface EfsMember {
+        efs: EfsStorageConfiguration;
+        fsx?: never;
+        $unknown?: never;
+    }
+    
+    interface FsxMember {
+        efs?: never;
+        fsx: FsxStorageConfiguration;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        efs?: never;
+        fsx?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        efs: (value: EfsStorageConfiguration) => T;
+        fsx: (value: FsxStorageConfiguration) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: StorageConfiguration, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: StorageConfiguration) => any;
+}
+export interface CreateEnvironmentRequest {
+    
+    name: string | undefined;
+    
+    instanceType: string | undefined;
+    
+    description?: string;
+    
+    engineType: EngineType | string | undefined;
+    
+    engineVersion?: string;
+    
+    subnetIds?: string[];
+    
+    securityGroupIds?: string[];
+    
+    storageConfigurations?: StorageConfiguration[];
+    
+    publiclyAccessible?: boolean;
+    
+    highAvailabilityConfig?: HighAvailabilityConfig;
+    
+    tags?: Record<string, string>;
+    
+    preferredMaintenanceWindow?: string;
+    
+    clientToken?: string;
+}
+export declare namespace CreateEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentRequest) => any;
+}
+export interface CreateEnvironmentResponse {
+    
+    environmentId: string | undefined;
+}
+export declare namespace CreateEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentResponse) => any;
+}
+export interface DeleteEnvironmentRequest {
+    
+    environmentId: string | undefined;
+}
+export declare namespace DeleteEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentRequest) => any;
+}
+export interface DeleteEnvironmentResponse {
+}
+export declare namespace DeleteEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentResponse) => any;
+}
+export interface GetEnvironmentRequest {
+    
+    environmentId: string | undefined;
+}
+export declare namespace GetEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentRequest) => any;
+}
+
+export interface MaintenanceSchedule {
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+}
+export declare namespace MaintenanceSchedule {
+    
+    const filterSensitiveLog: (obj: MaintenanceSchedule) => any;
+}
+
+export interface PendingMaintenance {
+    
+    schedule?: MaintenanceSchedule;
+    
+    engineVersion?: string;
+}
+export declare namespace PendingMaintenance {
+    
+    const filterSensitiveLog: (obj: PendingMaintenance) => any;
+}
+export declare enum EnvironmentLifecycle {
+    AVAILABLE = "Available",
+    CREATING = "Creating",
+    DELETING = "Deleting",
+    FAILED = "Failed"
+}
+export interface GetEnvironmentResponse {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    environmentArn: string | undefined;
+    
+    environmentId: string | undefined;
+    
+    instanceType: string | undefined;
+    
+    status: EnvironmentLifecycle | string | undefined;
+    
+    engineType: EngineType | string | undefined;
+    
+    engineVersion: string | undefined;
+    
+    vpcId: string | undefined;
+    
+    subnetIds: string[] | undefined;
+    
+    securityGroupIds: string[] | undefined;
+    
+    creationTime: Date | undefined;
+    
+    storageConfigurations?: StorageConfiguration[];
+    
+    tags?: Record<string, string>;
+    
+    highAvailabilityConfig?: HighAvailabilityConfig;
+    
+    publiclyAccessible?: boolean;
+    
+    actualCapacity?: number;
+    
+    loadBalancerArn?: string;
+    
+    statusReason?: string;
+    
+    preferredMaintenanceWindow?: string;
+    
+    pendingMaintenance?: PendingMaintenance;
+}
+export declare namespace GetEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentResponse) => any;
+}
+export interface ListEnvironmentsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    names?: string[];
+    
+    engineType?: EngineType | string;
+}
+export declare namespace ListEnvironmentsRequest {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentsRequest) => any;
+}
+
+export interface EnvironmentSummary {
+    
+    name: string | undefined;
+    
+    environmentArn: string | undefined;
+    
+    environmentId: string | undefined;
+    
+    instanceType: string | undefined;
+    
+    status: EnvironmentLifecycle | string | undefined;
+    
+    engineType: EngineType | string | undefined;
+    
+    engineVersion: string | undefined;
+    
+    creationTime: Date | undefined;
+}
+export declare namespace EnvironmentSummary {
+    
+    const filterSensitiveLog: (obj: EnvironmentSummary) => any;
+}
+export interface ListEnvironmentsResponse {
+    
+    environments: EnvironmentSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListEnvironmentsResponse {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentsResponse) => any;
+}
+export interface UpdateEnvironmentRequest {
+    
+    environmentId: string | undefined;
+    
+    desiredCapacity?: number;
+    
+    instanceType?: string;
+    
+    engineVersion?: string;
+    
+    preferredMaintenanceWindow?: string;
+    
+    applyDuringMaintenanceWindow?: boolean;
+}
+export declare namespace UpdateEnvironmentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentRequest) => any;
+}
+export interface UpdateEnvironmentResponse {
+    
+    environmentId: string | undefined;
+}
+export declare namespace UpdateEnvironmentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentResponse) => any;
+}
+export interface ListEngineVersionsRequest {
+    
+    engineType?: EngineType | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListEngineVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListEngineVersionsRequest) => any;
+}
+
+export interface EngineVersionsSummary {
+    
+    engineType: string | undefined;
+    
+    engineVersion: string | undefined;
+}
+export declare namespace EngineVersionsSummary {
+    
+    const filterSensitiveLog: (obj: EngineVersionsSummary) => any;
+}
+export interface ListEngineVersionsResponse {
+    
+    engineVersions: EngineVersionsSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListEngineVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListEngineVersionsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags: Record<string, string> | undefined;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Record<string, string> | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}