@aws-sdk/client-emr-serverless 3.100.0

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

@@ -0,0 +1,1172 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { EMRServerlessServiceException as __BaseException } from "./EMRServerlessServiceException";
+/**
+ * <p>The configuration for an application to automatically start on job submission.</p>
+ */
+export interface AutoStartConfig {
+    /**
+     * <p>Enables the application to automatically start on job submission. Defaults to true.</p>
+     */
+    enabled?: boolean;
+}
+export declare namespace AutoStartConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AutoStartConfig) => any;
+}
+/**
+ * <p>The configuration for an application to automatically stop after a certain amount of time being idle.</p>
+ */
+export interface AutoStopConfig {
+    /**
+     * <p>Enables the application to automatically stop after a certain amount of time being idle. Defaults to true.</p>
+     */
+    enabled?: boolean;
+    /**
+     * <p>The amount of idle time in minutes after which your application will automatically stop. Defaults to 15 minutes.</p>
+     */
+    idleTimeoutMinutes?: number;
+}
+export declare namespace AutoStopConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AutoStopConfig) => any;
+}
+/**
+ * <p>The cumulative configuration requirements for every worker instance of the worker
+ *          type.</p>
+ */
+export interface WorkerResourceConfig {
+    /**
+     * <p>The CPU requirements for every worker instance of the worker type.</p>
+     */
+    cpu: string | undefined;
+    /**
+     * <p>The memory requirements for every worker instance of the worker type.</p>
+     */
+    memory: string | undefined;
+    /**
+     * <p>The disk requirements for every worker instance of the worker type.</p>
+     */
+    disk?: string;
+}
+export declare namespace WorkerResourceConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: WorkerResourceConfig) => any;
+}
+/**
+ * <p>The initial capacity configuration per worker.</p>
+ */
+export interface InitialCapacityConfig {
+    /**
+     * <p>The number of workers in the initial capacity configuration.</p>
+     */
+    workerCount: number | undefined;
+    /**
+     * <p>The resource configuration of the initial capacity configuration.</p>
+     */
+    workerConfiguration?: WorkerResourceConfig;
+}
+export declare namespace InitialCapacityConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: InitialCapacityConfig) => any;
+}
+/**
+ * <p>The maximum allowed cumulative resources for an application. No new resources will be
+ *          created once the limit is hit.</p>
+ */
+export interface MaximumAllowedResources {
+    /**
+     * <p>The maximum allowed CPU for an application.</p>
+     */
+    cpu: string | undefined;
+    /**
+     * <p>The maximum allowed resources for an application.</p>
+     */
+    memory: string | undefined;
+    /**
+     * <p>The maximum allowed disk for an application.</p>
+     */
+    disk?: string;
+}
+export declare namespace MaximumAllowedResources {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: MaximumAllowedResources) => any;
+}
+/**
+ * <p>The network configuration for customer VPC connectivity.</p>
+ */
+export interface NetworkConfiguration {
+    /**
+     * <p>The array of subnet Ids for customer VPC connectivity.</p>
+     */
+    subnetIds?: string[];
+    /**
+     * <p>The array of security group Ids for customer VPC connectivity.</p>
+     */
+    securityGroupIds?: string[];
+}
+export declare namespace NetworkConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: NetworkConfiguration) => any;
+}
+export declare enum ApplicationState {
+    CREATED = "CREATED",
+    CREATING = "CREATING",
+    STARTED = "STARTED",
+    STARTING = "STARTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING",
+    TERMINATED = "TERMINATED"
+}
+/**
+ * <p>Information about an application. EMR Serverless uses applications to run jobs.</p>
+ */
+export interface Application {
+    /**
+     * <p>The ID of the application.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The name of the application.</p>
+     */
+    name?: string;
+    /**
+     * <p>The ARN of the application.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The EMR release version associated with the application.</p>
+     */
+    releaseLabel: string | undefined;
+    /**
+     * <p>The type of application, such as Spark or Hive.</p>
+     */
+    type: string | undefined;
+    /**
+     * <p>The state of the application.</p>
+     */
+    state: ApplicationState | string | undefined;
+    /**
+     * <p>The state details of the application.</p>
+     */
+    stateDetails?: string;
+    /**
+     * <p>The initial capacity of the application.</p>
+     */
+    initialCapacity?: {
+        [key: string]: InitialCapacityConfig;
+    };
+    /**
+     * <p>The maximum capacity of the application. This is cumulative across all workers at any
+     *          given point in time during the lifespan of the application is created. No new resources
+     *          will be created once any one of the defined limits is hit.</p>
+     */
+    maximumCapacity?: MaximumAllowedResources;
+    /**
+     * <p>The date and time when the application run was created.</p>
+     */
+    createdAt: Date | undefined;
+    /**
+     * <p>The date and time when the application run was last updated.</p>
+     */
+    updatedAt: Date | undefined;
+    /**
+     * <p>The tags assigned to the application.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The configuration for an application to automatically start on job submission.</p>
+     */
+    autoStartConfiguration?: AutoStartConfig;
+    /**
+     * <p>The configuration for an application to automatically stop after a certain amount of time being idle.</p>
+     */
+    autoStopConfiguration?: AutoStopConfig;
+    /**
+     * <p>The network configuration for customer VPC connectivity for the application.</p>
+     */
+    networkConfiguration?: NetworkConfiguration;
+}
+export declare namespace Application {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Application) => any;
+}
+/**
+ * <p>The summary of attributes associated with an application.</p>
+ */
+export interface ApplicationSummary {
+    /**
+     * <p>The ID of the application.</p>
+     */
+    id: string | undefined;
+    /**
+     * <p>The name of the application.</p>
+     */
+    name?: string;
+    /**
+     * <p>The ARN of the application.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The EMR release version associated with the application.</p>
+     */
+    releaseLabel: string | undefined;
+    /**
+     * <p>The type of application, such as Spark or Hive.</p>
+     */
+    type: string | undefined;
+    /**
+     * <p>The state of the application.</p>
+     */
+    state: ApplicationState | string | undefined;
+    /**
+     * <p>The state details of the application.</p>
+     */
+    stateDetails?: string;
+    /**
+     * <p>The date and time when the application was created.</p>
+     */
+    createdAt: Date | undefined;
+    /**
+     * <p>The date and time when the application was last updated.</p>
+     */
+    updatedAt: Date | undefined;
+}
+export declare namespace ApplicationSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ApplicationSummary) => any;
+}
+/**
+ * <p>The request could not be processed because of conflict in the current state of the
+ *          resource.</p>
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export interface CreateApplicationRequest {
+    /**
+     * <p>The name of the application.</p>
+     */
+    name?: string;
+    /**
+     * <p>The EMR release version associated with the application.</p>
+     */
+    releaseLabel: string | undefined;
+    /**
+     * <p>The type of application you want to start, such as Spark or Hive.</p>
+     */
+    type: string | undefined;
+    /**
+     * <p>The client idempotency token of the application to create. Its value must be unique for
+     *          each request.</p>
+     */
+    clientToken?: string;
+    /**
+     * <p>The capacity to initialize when the application is created.</p>
+     */
+    initialCapacity?: {
+        [key: string]: InitialCapacityConfig;
+    };
+    /**
+     * <p>The maximum capacity to allocate when the application is created. This is cumulative
+     *          across all workers at any given point in time, not just when an application is created. No
+     *          new resources will be created once any one of the defined limits is hit.</p>
+     */
+    maximumCapacity?: MaximumAllowedResources;
+    /**
+     * <p>The tags assigned to the application.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The configuration for an application to automatically start on job submission.</p>
+     */
+    autoStartConfiguration?: AutoStartConfig;
+    /**
+     * <p>The configuration for an application to automatically stop after a certain amount of time being idle.</p>
+     */
+    autoStopConfiguration?: AutoStopConfig;
+    /**
+     * <p>The network configuration for customer VPC connectivity.</p>
+     */
+    networkConfiguration?: NetworkConfiguration;
+}
+export declare namespace CreateApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateApplicationRequest) => any;
+}
+export interface CreateApplicationResponse {
+    /**
+     * <p>The output contains the application ID.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The output contains the name of the application.</p>
+     */
+    name?: string;
+    /**
+     * <p>The output contains the ARN of the application.</p>
+     */
+    arn: string | undefined;
+}
+export declare namespace CreateApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateApplicationResponse) => any;
+}
+/**
+ * <p>Request processing failed because of an error or failure with the service.</p>
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface DeleteApplicationRequest {
+    /**
+     * <p>The ID of the application that will be deleted.</p>
+     */
+    applicationId: string | undefined;
+}
+export declare namespace DeleteApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteApplicationRequest) => any;
+}
+export interface DeleteApplicationResponse {
+}
+export declare namespace DeleteApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteApplicationResponse) => any;
+}
+/**
+ * <p>The specified resource was not found.</p>
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface GetApplicationRequest {
+    /**
+     * <p>The ID of the application that will be described.</p>
+     */
+    applicationId: string | undefined;
+}
+export declare namespace GetApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetApplicationRequest) => any;
+}
+export interface GetApplicationResponse {
+    /**
+     * <p>The output displays information about the specified application.</p>
+     */
+    application: Application | undefined;
+}
+export declare namespace GetApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetApplicationResponse) => any;
+}
+export interface ListApplicationsRequest {
+    /**
+     * <p>The token for the next set of application results.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of applications that can be listed.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>An optional filter for application states. Note that if this filter contains multiple states, the resulting list will be grouped by the state.</p>
+     */
+    states?: (ApplicationState | string)[];
+}
+export declare namespace ListApplicationsRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListApplicationsRequest) => any;
+}
+export interface ListApplicationsResponse {
+    /**
+     * <p>The output lists the specified applications.</p>
+     */
+    applications: ApplicationSummary[] | undefined;
+    /**
+     * <p>The output displays the token for the next set of application results. This is required
+     *          for pagination and is available as a response of the previous request.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListApplicationsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListApplicationsResponse) => any;
+}
+/**
+ * <p>The maximum number of resources per account has been reached.</p>
+ */
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+export interface StartApplicationRequest {
+    /**
+     * <p>The ID of the application to start.</p>
+     */
+    applicationId: string | undefined;
+}
+export declare namespace StartApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartApplicationRequest) => any;
+}
+export interface StartApplicationResponse {
+}
+export declare namespace StartApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartApplicationResponse) => any;
+}
+export interface StopApplicationRequest {
+    /**
+     * <p>The ID of the application to stop.</p>
+     */
+    applicationId: string | undefined;
+}
+export declare namespace StopApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopApplicationRequest) => any;
+}
+export interface StopApplicationResponse {
+}
+export declare namespace StopApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopApplicationResponse) => any;
+}
+export interface UpdateApplicationRequest {
+    /**
+     * <p>The ID of the application to update.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The client idempotency token of the application to update. Its value must be unique for
+     *          each request.</p>
+     */
+    clientToken?: string;
+    /**
+     * <p>The capacity to initialize when the application is updated.</p>
+     */
+    initialCapacity?: {
+        [key: string]: InitialCapacityConfig;
+    };
+    /**
+     * <p>The maximum capacity to allocate when the application is updated. This is cumulative
+     *          across all workers at any given point in time during the lifespan of the application. No
+     *          new resources will be created once any one of the defined limits is hit.</p>
+     */
+    maximumCapacity?: MaximumAllowedResources;
+    /**
+     * <p>The configuration for an application to automatically start on job submission.</p>
+     */
+    autoStartConfiguration?: AutoStartConfig;
+    /**
+     * <p>The configuration for an application to automatically stop after a certain amount of time being idle.</p>
+     */
+    autoStopConfiguration?: AutoStopConfig;
+    /**
+     * <p>The network configuration for customer VPC connectivity.</p>
+     */
+    networkConfiguration?: NetworkConfiguration;
+}
+export declare namespace UpdateApplicationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateApplicationRequest) => any;
+}
+export interface UpdateApplicationResponse {
+    /**
+     * <p>Information about the updated application.</p>
+     */
+    application: Application | undefined;
+}
+export declare namespace UpdateApplicationResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateApplicationResponse) => any;
+}
+export interface CancelJobRunRequest {
+    /**
+     * <p>The ID of the application on which the job run will be canceled.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The ID of the job run to cancel.</p>
+     */
+    jobRunId: string | undefined;
+}
+export declare namespace CancelJobRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CancelJobRunRequest) => any;
+}
+export interface CancelJobRunResponse {
+    /**
+     * <p>The output contains the application ID on which the job run is cancelled.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The output contains the ID of the cancelled job run.</p>
+     */
+    jobRunId: string | undefined;
+}
+export declare namespace CancelJobRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CancelJobRunResponse) => any;
+}
+export interface GetJobRunRequest {
+    /**
+     * <p>The ID of the application on which the job run is submitted.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The ID of the job run.</p>
+     */
+    jobRunId: string | undefined;
+}
+export declare namespace GetJobRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetJobRunRequest) => any;
+}
+/**
+ * <p>The managed log persistence configuration for a job run.</p>
+ */
+export interface ManagedPersistenceMonitoringConfiguration {
+    /**
+     * <p>Enables managed logging and defaults to true. If set to false, managed logging will be turned off.</p>
+     */
+    enabled?: boolean;
+    /**
+     * <p>The KMS key ARN to encrypt the logs stored in managed log persistence.</p>
+     */
+    encryptionKeyArn?: string;
+}
+export declare namespace ManagedPersistenceMonitoringConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ManagedPersistenceMonitoringConfiguration) => any;
+}
+/**
+ * <p>The Amazon S3 configuration for monitoring log publishing. You can configure your jobs
+ *          to send log information to Amazon S3.</p>
+ */
+export interface S3MonitoringConfiguration {
+    /**
+     * <p>The Amazon S3 destination URI for log publishing.</p>
+     */
+    logUri?: string;
+    /**
+     * <p>The KMS key ARN to encrypt the logs published to the given Amazon S3 destination.</p>
+     */
+    encryptionKeyArn?: string;
+}
+export declare namespace S3MonitoringConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: S3MonitoringConfiguration) => any;
+}
+/**
+ * <p>The configuration setting for monitoring.</p>
+ */
+export interface MonitoringConfiguration {
+    /**
+     * <p>The Amazon S3 configuration for monitoring log publishing.</p>
+     */
+    s3MonitoringConfiguration?: S3MonitoringConfiguration;
+    /**
+     * <p>The managed log persistence configuration for a job run.</p>
+     */
+    managedPersistenceMonitoringConfiguration?: ManagedPersistenceMonitoringConfiguration;
+}
+export declare namespace MonitoringConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: MonitoringConfiguration) => any;
+}
+/**
+ * <p>The configurations for the Hive job driver.</p>
+ */
+export interface Hive {
+    /**
+     * <p>The query for the Hive job run.</p>
+     */
+    query: string | undefined;
+    /**
+     * <p>The query file for the Hive job run.</p>
+     */
+    initQueryFile?: string;
+    /**
+     * <p>The parameters for the Hive job run.</p>
+     */
+    parameters?: string;
+}
+export declare namespace Hive {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Hive) => any;
+}
+/**
+ * <p>The configurations for the Spark submit job driver.</p>
+ */
+export interface SparkSubmit {
+    /**
+     * <p>The entry point for the Spark submit job run.</p>
+     */
+    entryPoint: string | undefined;
+    /**
+     * <p>The arguments for the Spark submit job run.</p>
+     */
+    entryPointArguments?: string[];
+    /**
+     * <p>The parameters for the Spark submit job run.</p>
+     */
+    sparkSubmitParameters?: string;
+}
+export declare namespace SparkSubmit {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: SparkSubmit) => any;
+}
+/**
+ * <p>The driver that the job runs on.</p>
+ */
+export declare type JobDriver = JobDriver.HiveMember | JobDriver.SparkSubmitMember | JobDriver.$UnknownMember;
+export declare namespace JobDriver {
+    /**
+     * <p>The job driver parameters specified for Spark.</p>
+     */
+    interface SparkSubmitMember {
+        sparkSubmit: SparkSubmit;
+        hive?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>The job driver parameters specified for Hive.</p>
+     */
+    interface HiveMember {
+        sparkSubmit?: never;
+        hive: Hive;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        sparkSubmit?: never;
+        hive?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        sparkSubmit: (value: SparkSubmit) => T;
+        hive: (value: Hive) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: JobDriver, visitor: Visitor<T>) => T;
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: JobDriver) => any;
+}
+export declare enum JobRunState {
+    CANCELLED = "CANCELLED",
+    CANCELLING = "CANCELLING",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SCHEDULED = "SCHEDULED",
+    SUBMITTED = "SUBMITTED",
+    SUCCESS = "SUCCESS"
+}
+/**
+ * <p>The aggregate vCPU, memory, and storage resources used from the time job start executing till the time job is terminated,
+ *           rounded up to the nearest second.</p>
+ */
+export interface TotalResourceUtilization {
+    /**
+     * <p>The aggregated vCPU used per hour from the time job start executing till the time job is terminated.</p>
+     */
+    vCPUHour?: number;
+    /**
+     * <p>The aggregated memory used per hour from the time job start executing till the time job is terminated.</p>
+     */
+    memoryGBHour?: number;
+    /**
+     * <p>The aggregated storage used per hour from the time job start executing till the time job is terminated.</p>
+     */
+    storageGBHour?: number;
+}
+export declare namespace TotalResourceUtilization {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TotalResourceUtilization) => any;
+}
+export interface ListJobRunsRequest {
+    /**
+     * <p>The ID of the application for which to list the job run.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The token for the next set of job run results.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of job runs that can be listed.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The lower bound of the option to filter by creation date and time.</p>
+     */
+    createdAtAfter?: Date;
+    /**
+     * <p>The upper bound of the option to filter by creation date and time.</p>
+     */
+    createdAtBefore?: Date;
+    /**
+     * <p>An optional filter for job run states. Note that if this filter contains multiple states, the resulting list will be grouped by the state.</p>
+     */
+    states?: (JobRunState | string)[];
+}
+export declare namespace ListJobRunsRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListJobRunsRequest) => any;
+}
+/**
+ * <p>The summary of attributes associated with a job run.</p>
+ */
+export interface JobRunSummary {
+    /**
+     * <p>The ID of the application the job is running on.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The ID of the job run.</p>
+     */
+    id: string | undefined;
+    /**
+     * <p>The optional job run name. This doesn't have to be unique.</p>
+     */
+    name?: string;
+    /**
+     * <p>The ARN of the job run.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The user who created the job run.</p>
+     */
+    createdBy: string | undefined;
+    /**
+     * <p>The date and time when the job run was created.</p>
+     */
+    createdAt: Date | undefined;
+    /**
+     * <p>The date and time when the job run was last updated.</p>
+     */
+    updatedAt: Date | undefined;
+    /**
+     * <p>The execution role ARN of the job run.</p>
+     */
+    executionRole: string | undefined;
+    /**
+     * <p>The state of the job run.</p>
+     */
+    state: JobRunState | string | undefined;
+    /**
+     * <p>The state details of the job run.</p>
+     */
+    stateDetails: string | undefined;
+    /**
+     * <p>The EMR release version associated with the application your job is running on.</p>
+     */
+    releaseLabel: string | undefined;
+    /**
+     * <p>The type of job run, such as Spark or Hive.</p>
+     */
+    type?: string;
+}
+export declare namespace JobRunSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: JobRunSummary) => any;
+}
+export interface ListJobRunsResponse {
+    /**
+     * <p>The output lists information about the specified job runs.</p>
+     */
+    jobRuns: JobRunSummary[] | undefined;
+    /**
+     * <p>The output displays the token for the next set of job run results. This is required for
+     *          pagination and is available as a response of the previous request.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListJobRunsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListJobRunsResponse) => any;
+}
+export interface StartJobRunResponse {
+    /**
+     * <p>This output displays the application ID on which the job run was submitted.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The output contains the ID of the started job run.</p>
+     */
+    jobRunId: string | undefined;
+    /**
+     * <p>The output lists the execution role ARN of the job run.</p>
+     */
+    arn: string | undefined;
+}
+export declare namespace StartJobRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartJobRunResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the resource to list the tags for. Currently, the supported resources are Amazon EMR Serverless applications and job runs.</p>
+     */
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    /**
+     * <p>The tags for the resource.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the resource to list the tags for. Currently, the supported resources are Amazon EMR Serverless applications and job runs.</p>
+     */
+    resourceArn: string | undefined;
+    /**
+     * <p>The tags to add to the resource. A tag is an array of key-value pairs.</p>
+     */
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) that identifies the resource to list the tags for. Currently, the supported resources are Amazon EMR Serverless applications and job runs.</p>
+     */
+    resourceArn: string | undefined;
+    /**
+     * <p>The keys of the tags to be removed.</p>
+     */
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+/**
+ * <p>A configuration specification to be used when provisioning an application. A
+ *          configuration consists of a classification, properties, and optional nested configurations.
+ *          A classification refers to an application-specific configuration file. Properties are the
+ *          settings you want to change in that file.</p>
+ */
+export interface Configuration {
+    /**
+     * <p>The classification within a configuration.</p>
+     */
+    classification: string | undefined;
+    /**
+     * <p>A set of properties specified within a configuration classification.</p>
+     */
+    properties?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>A list of additional configurations to apply within a configuration object.</p>
+     */
+    configurations?: Configuration[];
+}
+export declare namespace Configuration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Configuration) => any;
+}
+/**
+ * <p>A configuration specification to be used to override existing configurations.</p>
+ */
+export interface ConfigurationOverrides {
+    /**
+     * <p>The override configurations for the application.</p>
+     */
+    applicationConfiguration?: Configuration[];
+    /**
+     * <p>The override configurations for monitoring.</p>
+     */
+    monitoringConfiguration?: MonitoringConfiguration;
+}
+export declare namespace ConfigurationOverrides {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ConfigurationOverrides) => any;
+}
+/**
+ * <p>Information about a job run. A job run is a unit of work, such as a Spark JAR, Hive
+ *          query, or SparkSQL query, that you submit to an EMR Serverless application.</p>
+ */
+export interface JobRun {
+    /**
+     * <p>The ID of the application the job is running on.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The ID of the job run.</p>
+     */
+    jobRunId: string | undefined;
+    /**
+     * <p>The optional job run name. This doesn't have to be unique.</p>
+     */
+    name?: string;
+    /**
+     * <p>The execution role ARN of the job run.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The user who created the job run.</p>
+     */
+    createdBy: string | undefined;
+    /**
+     * <p>The date and time when the job run was created.</p>
+     */
+    createdAt: Date | undefined;
+    /**
+     * <p>The date and time when the job run was updated.</p>
+     */
+    updatedAt: Date | undefined;
+    /**
+     * <p>The execution role ARN of the job run.</p>
+     */
+    executionRole: string | undefined;
+    /**
+     * <p>The state of the job run.</p>
+     */
+    state: JobRunState | string | undefined;
+    /**
+     * <p>The state details of the job run.</p>
+     */
+    stateDetails: string | undefined;
+    /**
+     * <p>The EMR release version associated with the application your job is running on.</p>
+     */
+    releaseLabel: string | undefined;
+    /**
+     * <p>The configuration settings that are used to override default configuration.</p>
+     */
+    configurationOverrides?: ConfigurationOverrides;
+    /**
+     * <p>The job driver for the job run.</p>
+     */
+    jobDriver: JobDriver | undefined;
+    /**
+     * <p>The tags assigned to the job run.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The aggregate vCPU, memory, and storage resources used from the time job start executing till the time job is terminated,
+     *           rounded up to the nearest second.</p>
+     */
+    totalResourceUtilization?: TotalResourceUtilization;
+    /**
+     * <p>The network configuration for customer VPC connectivity.</p>
+     */
+    networkConfiguration?: NetworkConfiguration;
+    /**
+     * <p>The job run total execution duration in seconds. This field is only available for job runs in a <code>COMPLETED</code>, <code>FAILED</code>, or <code>CANCELLED</code> state.</p>
+     */
+    totalExecutionDurationSeconds?: number;
+}
+export declare namespace JobRun {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: JobRun) => any;
+}
+export interface StartJobRunRequest {
+    /**
+     * <p>The ID of the application on which to run the job.</p>
+     */
+    applicationId: string | undefined;
+    /**
+     * <p>The client idempotency token of the job run to start. Its value must be unique for each
+     *          request.</p>
+     */
+    clientToken?: string;
+    /**
+     * <p>The execution role ARN for the job run.</p>
+     */
+    executionRoleArn: string | undefined;
+    /**
+     * <p>The job driver for the job run.</p>
+     */
+    jobDriver?: JobDriver;
+    /**
+     * <p>The configuration overrides for the job run.</p>
+     */
+    configurationOverrides?: ConfigurationOverrides;
+    /**
+     * <p>The tags assigned to the job run.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The maximum duration for the job run to run. If the job run runs beyond this duration, it will be automatically cancelled.</p>
+     */
+    executionTimeoutMinutes?: number;
+    /**
+     * <p>The optional job run name. This doesn't have to be unique.</p>
+     */
+    name?: string;
+}
+export declare namespace StartJobRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartJobRunRequest) => any;
+}
+export interface GetJobRunResponse {
+    /**
+     * <p>The output displays information about the job run.</p>
+     */
+    jobRun: JobRun | undefined;
+}
+export declare namespace GetJobRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetJobRunResponse) => any;
+}