@aws-sdk/client-emr-containers 3.50.0 → 3.53.0

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

@@ -0,0 +1,660 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { EMRContainersServiceException as __BaseException } from "./EMRContainersServiceException";
+export interface CancelJobRunRequest {
+    
+    id: string | undefined;
+    
+    virtualClusterId: string | undefined;
+}
+export declare namespace CancelJobRunRequest {
+    
+    const filterSensitiveLog: (obj: CancelJobRunRequest) => any;
+}
+export interface CancelJobRunResponse {
+    
+    id?: string;
+    
+    virtualClusterId?: string;
+}
+export declare namespace CancelJobRunResponse {
+    
+    const filterSensitiveLog: (obj: CancelJobRunResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface CloudWatchMonitoringConfiguration {
+    
+    logGroupName: string | undefined;
+    
+    logStreamNamePrefix?: string;
+}
+export declare namespace CloudWatchMonitoringConfiguration {
+    
+    const filterSensitiveLog: (obj: CloudWatchMonitoringConfiguration) => any;
+}
+export declare enum PersistentAppUI {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface S3MonitoringConfiguration {
+    
+    logUri: string | undefined;
+}
+export declare namespace S3MonitoringConfiguration {
+    
+    const filterSensitiveLog: (obj: S3MonitoringConfiguration) => any;
+}
+
+export interface MonitoringConfiguration {
+    
+    persistentAppUI?: PersistentAppUI | string;
+    
+    cloudWatchMonitoringConfiguration?: CloudWatchMonitoringConfiguration;
+    
+    s3MonitoringConfiguration?: S3MonitoringConfiguration;
+}
+export declare namespace MonitoringConfiguration {
+    
+    const filterSensitiveLog: (obj: MonitoringConfiguration) => any;
+}
+export interface CreateManagedEndpointResponse {
+    
+    id?: string;
+    
+    name?: string;
+    
+    arn?: string;
+    
+    virtualClusterId?: string;
+}
+export declare namespace CreateManagedEndpointResponse {
+    
+    const filterSensitiveLog: (obj: CreateManagedEndpointResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export interface EksInfo {
+    
+    namespace?: string;
+}
+export declare namespace EksInfo {
+    
+    const filterSensitiveLog: (obj: EksInfo) => any;
+}
+
+export declare type ContainerInfo = ContainerInfo.EksInfoMember | ContainerInfo.$UnknownMember;
+export declare namespace ContainerInfo {
+    
+    interface EksInfoMember {
+        eksInfo: EksInfo;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        eksInfo?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        eksInfo: (value: EksInfo) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ContainerInfo, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ContainerInfo) => any;
+}
+export declare enum ContainerProviderType {
+    EKS = "EKS"
+}
+
+export interface ContainerProvider {
+    
+    type: ContainerProviderType | string | undefined;
+    
+    id: string | undefined;
+    
+    info?: ContainerInfo;
+}
+export declare namespace ContainerProvider {
+    
+    const filterSensitiveLog: (obj: ContainerProvider) => any;
+}
+export interface CreateVirtualClusterRequest {
+    
+    name: string | undefined;
+    
+    containerProvider: ContainerProvider | undefined;
+    
+    clientToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateVirtualClusterRequest {
+    
+    const filterSensitiveLog: (obj: CreateVirtualClusterRequest) => any;
+}
+export interface CreateVirtualClusterResponse {
+    
+    id?: string;
+    
+    name?: string;
+    
+    arn?: string;
+}
+export declare namespace CreateVirtualClusterResponse {
+    
+    const filterSensitiveLog: (obj: CreateVirtualClusterResponse) => any;
+}
+export interface DeleteManagedEndpointRequest {
+    
+    id: string | undefined;
+    
+    virtualClusterId: string | undefined;
+}
+export declare namespace DeleteManagedEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteManagedEndpointRequest) => any;
+}
+export interface DeleteManagedEndpointResponse {
+    
+    id?: string;
+    
+    virtualClusterId?: string;
+}
+export declare namespace DeleteManagedEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DeleteManagedEndpointResponse) => any;
+}
+export interface DeleteVirtualClusterRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeleteVirtualClusterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualClusterRequest) => any;
+}
+export interface DeleteVirtualClusterResponse {
+    
+    id?: string;
+}
+export declare namespace DeleteVirtualClusterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteVirtualClusterResponse) => any;
+}
+export interface DescribeJobRunRequest {
+    
+    id: string | undefined;
+    
+    virtualClusterId: string | undefined;
+}
+export declare namespace DescribeJobRunRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobRunRequest) => any;
+}
+export declare enum FailureReason {
+    CLUSTER_UNAVAILABLE = "CLUSTER_UNAVAILABLE",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    USER_ERROR = "USER_ERROR",
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+}
+
+export interface SparkSubmitJobDriver {
+    
+    entryPoint: string | undefined;
+    
+    entryPointArguments?: string[];
+    
+    sparkSubmitParameters?: string;
+}
+export declare namespace SparkSubmitJobDriver {
+    
+    const filterSensitiveLog: (obj: SparkSubmitJobDriver) => any;
+}
+
+export interface JobDriver {
+    
+    sparkSubmitJobDriver?: SparkSubmitJobDriver;
+}
+export declare namespace JobDriver {
+    
+    const filterSensitiveLog: (obj: JobDriver) => any;
+}
+export declare enum JobRunState {
+    CANCELLED = "CANCELLED",
+    CANCEL_PENDING = "CANCEL_PENDING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUBMITTED = "SUBMITTED"
+}
+export interface DescribeManagedEndpointRequest {
+    
+    id: string | undefined;
+    
+    virtualClusterId: string | undefined;
+}
+export declare namespace DescribeManagedEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DescribeManagedEndpointRequest) => any;
+}
+
+export interface Certificate {
+    
+    certificateArn?: string;
+    
+    certificateData?: string;
+}
+export declare namespace Certificate {
+    
+    const filterSensitiveLog: (obj: Certificate) => any;
+}
+export declare enum EndpointState {
+    ACTIVE = "ACTIVE",
+    CREATING = "CREATING",
+    TERMINATED = "TERMINATED",
+    TERMINATED_WITH_ERRORS = "TERMINATED_WITH_ERRORS",
+    TERMINATING = "TERMINATING"
+}
+export interface DescribeVirtualClusterRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DescribeVirtualClusterRequest {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualClusterRequest) => any;
+}
+export declare enum VirtualClusterState {
+    ARRESTED = "ARRESTED",
+    RUNNING = "RUNNING",
+    TERMINATED = "TERMINATED",
+    TERMINATING = "TERMINATING"
+}
+
+export interface VirtualCluster {
+    
+    id?: string;
+    
+    name?: string;
+    
+    arn?: string;
+    
+    state?: VirtualClusterState | string;
+    
+    containerProvider?: ContainerProvider;
+    
+    createdAt?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace VirtualCluster {
+    
+    const filterSensitiveLog: (obj: VirtualCluster) => any;
+}
+export interface DescribeVirtualClusterResponse {
+    
+    virtualCluster?: VirtualCluster;
+}
+export declare namespace DescribeVirtualClusterResponse {
+    
+    const filterSensitiveLog: (obj: DescribeVirtualClusterResponse) => any;
+}
+export interface ListJobRunsRequest {
+    
+    virtualClusterId: string | undefined;
+    
+    createdBefore?: Date;
+    
+    createdAfter?: Date;
+    
+    name?: string;
+    
+    states?: (JobRunState | string)[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListJobRunsRequest {
+    
+    const filterSensitiveLog: (obj: ListJobRunsRequest) => any;
+}
+export interface ListManagedEndpointsRequest {
+    
+    virtualClusterId: string | undefined;
+    
+    createdBefore?: Date;
+    
+    createdAfter?: Date;
+    
+    types?: string[];
+    
+    states?: (EndpointState | string)[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListManagedEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: ListManagedEndpointsRequest) => 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 interface ListVirtualClustersRequest {
+    
+    containerProviderId?: string;
+    
+    containerProviderType?: ContainerProviderType | string;
+    
+    createdAfter?: Date;
+    
+    createdBefore?: Date;
+    
+    states?: (VirtualClusterState | string)[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualClustersRequest {
+    
+    const filterSensitiveLog: (obj: ListVirtualClustersRequest) => any;
+}
+export interface ListVirtualClustersResponse {
+    
+    virtualClusters?: VirtualCluster[];
+    
+    nextToken?: string;
+}
+export declare namespace ListVirtualClustersResponse {
+    
+    const filterSensitiveLog: (obj: ListVirtualClustersResponse) => any;
+}
+export interface StartJobRunResponse {
+    
+    id?: string;
+    
+    name?: string;
+    
+    arn?: string;
+    
+    virtualClusterId?: string;
+}
+export declare namespace StartJobRunResponse {
+    
+    const filterSensitiveLog: (obj: StartJobRunResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface Configuration {
+    
+    classification: string | undefined;
+    
+    properties?: {
+        [key: string]: string;
+    };
+    
+    configurations?: Configuration[];
+}
+export declare namespace Configuration {
+    
+    const filterSensitiveLog: (obj: Configuration) => any;
+}
+
+export interface ConfigurationOverrides {
+    
+    applicationConfiguration?: Configuration[];
+    
+    monitoringConfiguration?: MonitoringConfiguration;
+}
+export declare namespace ConfigurationOverrides {
+    
+    const filterSensitiveLog: (obj: ConfigurationOverrides) => any;
+}
+export interface CreateManagedEndpointRequest {
+    
+    name: string | undefined;
+    
+    virtualClusterId: string | undefined;
+    
+    type: string | undefined;
+    
+    releaseLabel: string | undefined;
+    
+    executionRoleArn: string | undefined;
+    
+    certificateArn?: string;
+    
+    configurationOverrides?: ConfigurationOverrides;
+    
+    clientToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateManagedEndpointRequest {
+    
+    const filterSensitiveLog: (obj: CreateManagedEndpointRequest) => any;
+}
+
+export interface Endpoint {
+    
+    id?: string;
+    
+    name?: string;
+    
+    arn?: string;
+    
+    virtualClusterId?: string;
+    
+    type?: string;
+    
+    state?: EndpointState | string;
+    
+    releaseLabel?: string;
+    
+    executionRoleArn?: string;
+    
+    certificateArn?: string;
+    
+    certificateAuthority?: Certificate;
+    
+    configurationOverrides?: ConfigurationOverrides;
+    
+    serverUrl?: string;
+    
+    createdAt?: Date;
+    
+    securityGroup?: string;
+    
+    subnetIds?: string[];
+    
+    stateDetails?: string;
+    
+    failureReason?: FailureReason | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+
+export interface JobRun {
+    
+    id?: string;
+    
+    name?: string;
+    
+    virtualClusterId?: string;
+    
+    arn?: string;
+    
+    state?: JobRunState | string;
+    
+    clientToken?: string;
+    
+    executionRoleArn?: string;
+    
+    releaseLabel?: string;
+    
+    configurationOverrides?: ConfigurationOverrides;
+    
+    jobDriver?: JobDriver;
+    
+    createdAt?: Date;
+    
+    createdBy?: string;
+    
+    finishedAt?: Date;
+    
+    stateDetails?: string;
+    
+    failureReason?: FailureReason | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace JobRun {
+    
+    const filterSensitiveLog: (obj: JobRun) => any;
+}
+export interface StartJobRunRequest {
+    
+    name?: string;
+    
+    virtualClusterId: string | undefined;
+    
+    clientToken?: string;
+    
+    executionRoleArn: string | undefined;
+    
+    releaseLabel: string | undefined;
+    
+    jobDriver: JobDriver | undefined;
+    
+    configurationOverrides?: ConfigurationOverrides;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartJobRunRequest {
+    
+    const filterSensitiveLog: (obj: StartJobRunRequest) => any;
+}
+export interface DescribeJobRunResponse {
+    
+    jobRun?: JobRun;
+}
+export declare namespace DescribeJobRunResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobRunResponse) => any;
+}
+export interface DescribeManagedEndpointResponse {
+    
+    endpoint?: Endpoint;
+}
+export declare namespace DescribeManagedEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DescribeManagedEndpointResponse) => any;
+}
+export interface ListJobRunsResponse {
+    
+    jobRuns?: JobRun[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobRunsResponse {
+    
+    const filterSensitiveLog: (obj: ListJobRunsResponse) => any;
+}
+export interface ListManagedEndpointsResponse {
+    
+    endpoints?: Endpoint[];
+    
+    nextToken?: string;
+}
+export declare namespace ListManagedEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: ListManagedEndpointsResponse) => any;
+}

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { EMRContainers } from "../EMRContainers";
+import { EMRContainersClient } from "../EMRContainersClient";
+export interface EMRContainersPaginationConfiguration extends PaginationConfiguration {
+    client: EMRContainers | EMRContainersClient;
+}

package/dist-types/ts3.4/pagination/ListJobRunsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListJobRunsCommandInput, ListJobRunsCommandOutput } from "../commands/ListJobRunsCommand";
+import { EMRContainersPaginationConfiguration } from "./Interfaces";
+export declare function paginateListJobRuns(config: EMRContainersPaginationConfiguration, input: ListJobRunsCommandInput, ...additionalArguments: any): Paginator<ListJobRunsCommandOutput>;

package/dist-types/ts3.4/pagination/ListManagedEndpointsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListManagedEndpointsCommandInput, ListManagedEndpointsCommandOutput } from "../commands/ListManagedEndpointsCommand";
+import { EMRContainersPaginationConfiguration } from "./Interfaces";
+export declare function paginateListManagedEndpoints(config: EMRContainersPaginationConfiguration, input: ListManagedEndpointsCommandInput, ...additionalArguments: any): Paginator<ListManagedEndpointsCommandOutput>;

package/dist-types/ts3.4/pagination/ListVirtualClustersPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListVirtualClustersCommandInput, ListVirtualClustersCommandOutput } from "../commands/ListVirtualClustersCommand";
+import { EMRContainersPaginationConfiguration } from "./Interfaces";
+export declare function paginateListVirtualClusters(config: EMRContainersPaginationConfiguration, input: ListVirtualClustersCommandInput, ...additionalArguments: any): Paginator<ListVirtualClustersCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Interfaces";
+export * from "./ListJobRunsPaginator";
+export * from "./ListManagedEndpointsPaginator";
+export * from "./ListVirtualClustersPaginator";