@aws-sdk/client-kinesis-analytics-v2 3.50.0 → 3.51.0

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

@@ -0,0 +1,2282 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface CloudWatchLoggingOption {
+    
+    LogStreamARN: string | undefined;
+}
+export declare namespace CloudWatchLoggingOption {
+    
+    const filterSensitiveLog: (obj: CloudWatchLoggingOption) => any;
+}
+export interface AddApplicationCloudWatchLoggingOptionRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId?: number;
+    
+    CloudWatchLoggingOption: CloudWatchLoggingOption | undefined;
+    
+    ConditionalToken?: string;
+}
+export declare namespace AddApplicationCloudWatchLoggingOptionRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationCloudWatchLoggingOptionRequest) => any;
+}
+
+export interface CloudWatchLoggingOptionDescription {
+    
+    CloudWatchLoggingOptionId?: string;
+    
+    LogStreamARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace CloudWatchLoggingOptionDescription {
+    
+    const filterSensitiveLog: (obj: CloudWatchLoggingOptionDescription) => any;
+}
+export interface AddApplicationCloudWatchLoggingOptionResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    CloudWatchLoggingOptionDescriptions?: CloudWatchLoggingOptionDescription[];
+}
+export declare namespace AddApplicationCloudWatchLoggingOptionResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationCloudWatchLoggingOptionResponse) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InvalidApplicationConfigurationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidApplicationConfigurationException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InvalidArgumentException extends __SmithyException, $MetadataBearer {
+    name: "InvalidArgumentException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InputParallelism {
+    
+    Count?: number;
+}
+export declare namespace InputParallelism {
+    
+    const filterSensitiveLog: (obj: InputParallelism) => any;
+}
+
+export interface InputLambdaProcessor {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace InputLambdaProcessor {
+    
+    const filterSensitiveLog: (obj: InputLambdaProcessor) => any;
+}
+
+export interface InputProcessingConfiguration {
+    
+    InputLambdaProcessor: InputLambdaProcessor | undefined;
+}
+export declare namespace InputProcessingConfiguration {
+    
+    const filterSensitiveLog: (obj: InputProcessingConfiguration) => any;
+}
+
+export interface RecordColumn {
+    
+    Name: string | undefined;
+    
+    Mapping?: string;
+    
+    SqlType: string | undefined;
+}
+export declare namespace RecordColumn {
+    
+    const filterSensitiveLog: (obj: RecordColumn) => any;
+}
+
+export interface CSVMappingParameters {
+    
+    RecordRowDelimiter: string | undefined;
+    
+    RecordColumnDelimiter: string | undefined;
+}
+export declare namespace CSVMappingParameters {
+    
+    const filterSensitiveLog: (obj: CSVMappingParameters) => any;
+}
+
+export interface JSONMappingParameters {
+    
+    RecordRowPath: string | undefined;
+}
+export declare namespace JSONMappingParameters {
+    
+    const filterSensitiveLog: (obj: JSONMappingParameters) => any;
+}
+
+export interface MappingParameters {
+    
+    JSONMappingParameters?: JSONMappingParameters;
+    
+    CSVMappingParameters?: CSVMappingParameters;
+}
+export declare namespace MappingParameters {
+    
+    const filterSensitiveLog: (obj: MappingParameters) => any;
+}
+export declare enum RecordFormatType {
+    CSV = "CSV",
+    JSON = "JSON"
+}
+
+export interface RecordFormat {
+    
+    RecordFormatType: RecordFormatType | string | undefined;
+    
+    MappingParameters?: MappingParameters;
+}
+export declare namespace RecordFormat {
+    
+    const filterSensitiveLog: (obj: RecordFormat) => any;
+}
+
+export interface SourceSchema {
+    
+    RecordFormat: RecordFormat | undefined;
+    
+    RecordEncoding?: string;
+    
+    RecordColumns: RecordColumn[] | undefined;
+}
+export declare namespace SourceSchema {
+    
+    const filterSensitiveLog: (obj: SourceSchema) => any;
+}
+
+export interface KinesisFirehoseInput {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace KinesisFirehoseInput {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseInput) => any;
+}
+
+export interface KinesisStreamsInput {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace KinesisStreamsInput {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsInput) => any;
+}
+
+export interface Input {
+    
+    NamePrefix: string | undefined;
+    
+    InputProcessingConfiguration?: InputProcessingConfiguration;
+    
+    KinesisStreamsInput?: KinesisStreamsInput;
+    
+    KinesisFirehoseInput?: KinesisFirehoseInput;
+    
+    InputParallelism?: InputParallelism;
+    
+    InputSchema: SourceSchema | undefined;
+}
+export declare namespace Input {
+    
+    const filterSensitiveLog: (obj: Input) => any;
+}
+export interface AddApplicationInputRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    Input: Input | undefined;
+}
+export declare namespace AddApplicationInputRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationInputRequest) => any;
+}
+
+export interface InputLambdaProcessorDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace InputLambdaProcessorDescription {
+    
+    const filterSensitiveLog: (obj: InputLambdaProcessorDescription) => any;
+}
+
+export interface InputProcessingConfigurationDescription {
+    
+    InputLambdaProcessorDescription?: InputLambdaProcessorDescription;
+}
+export declare namespace InputProcessingConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: InputProcessingConfigurationDescription) => any;
+}
+export declare enum InputStartingPosition {
+    LAST_STOPPED_POINT = "LAST_STOPPED_POINT",
+    NOW = "NOW",
+    TRIM_HORIZON = "TRIM_HORIZON"
+}
+
+export interface InputStartingPositionConfiguration {
+    
+    InputStartingPosition?: InputStartingPosition | string;
+}
+export declare namespace InputStartingPositionConfiguration {
+    
+    const filterSensitiveLog: (obj: InputStartingPositionConfiguration) => any;
+}
+
+export interface KinesisFirehoseInputDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace KinesisFirehoseInputDescription {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseInputDescription) => any;
+}
+
+export interface KinesisStreamsInputDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace KinesisStreamsInputDescription {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsInputDescription) => any;
+}
+
+export interface InputDescription {
+    
+    InputId?: string;
+    
+    NamePrefix?: string;
+    
+    InAppStreamNames?: string[];
+    
+    InputProcessingConfigurationDescription?: InputProcessingConfigurationDescription;
+    
+    KinesisStreamsInputDescription?: KinesisStreamsInputDescription;
+    
+    KinesisFirehoseInputDescription?: KinesisFirehoseInputDescription;
+    
+    InputSchema?: SourceSchema;
+    
+    InputParallelism?: InputParallelism;
+    
+    InputStartingPositionConfiguration?: InputStartingPositionConfiguration;
+}
+export declare namespace InputDescription {
+    
+    const filterSensitiveLog: (obj: InputDescription) => any;
+}
+export interface AddApplicationInputResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    InputDescriptions?: InputDescription[];
+}
+export declare namespace AddApplicationInputResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationInputResponse) => any;
+}
+
+export interface CodeValidationException extends __SmithyException, $MetadataBearer {
+    name: "CodeValidationException";
+    $fault: "client";
+    Message?: string;
+}
+export interface AddApplicationInputProcessingConfigurationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    InputId: string | undefined;
+    
+    InputProcessingConfiguration: InputProcessingConfiguration | undefined;
+}
+export declare namespace AddApplicationInputProcessingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationInputProcessingConfigurationRequest) => any;
+}
+export interface AddApplicationInputProcessingConfigurationResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    InputId?: string;
+    
+    InputProcessingConfigurationDescription?: InputProcessingConfigurationDescription;
+}
+export declare namespace AddApplicationInputProcessingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationInputProcessingConfigurationResponse) => any;
+}
+
+export interface DestinationSchema {
+    
+    RecordFormatType: RecordFormatType | string | undefined;
+}
+export declare namespace DestinationSchema {
+    
+    const filterSensitiveLog: (obj: DestinationSchema) => any;
+}
+
+export interface KinesisFirehoseOutput {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace KinesisFirehoseOutput {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseOutput) => any;
+}
+
+export interface KinesisStreamsOutput {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace KinesisStreamsOutput {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsOutput) => any;
+}
+
+export interface LambdaOutput {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace LambdaOutput {
+    
+    const filterSensitiveLog: (obj: LambdaOutput) => any;
+}
+
+export interface Output {
+    
+    Name: string | undefined;
+    
+    KinesisStreamsOutput?: KinesisStreamsOutput;
+    
+    KinesisFirehoseOutput?: KinesisFirehoseOutput;
+    
+    LambdaOutput?: LambdaOutput;
+    
+    DestinationSchema: DestinationSchema | undefined;
+}
+export declare namespace Output {
+    
+    const filterSensitiveLog: (obj: Output) => any;
+}
+export interface AddApplicationOutputRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    Output: Output | undefined;
+}
+export declare namespace AddApplicationOutputRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationOutputRequest) => any;
+}
+
+export interface KinesisFirehoseOutputDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace KinesisFirehoseOutputDescription {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseOutputDescription) => any;
+}
+
+export interface KinesisStreamsOutputDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace KinesisStreamsOutputDescription {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsOutputDescription) => any;
+}
+
+export interface LambdaOutputDescription {
+    
+    ResourceARN: string | undefined;
+    
+    RoleARN?: string;
+}
+export declare namespace LambdaOutputDescription {
+    
+    const filterSensitiveLog: (obj: LambdaOutputDescription) => any;
+}
+
+export interface OutputDescription {
+    
+    OutputId?: string;
+    
+    Name?: string;
+    
+    KinesisStreamsOutputDescription?: KinesisStreamsOutputDescription;
+    
+    KinesisFirehoseOutputDescription?: KinesisFirehoseOutputDescription;
+    
+    LambdaOutputDescription?: LambdaOutputDescription;
+    
+    DestinationSchema?: DestinationSchema;
+}
+export declare namespace OutputDescription {
+    
+    const filterSensitiveLog: (obj: OutputDescription) => any;
+}
+export interface AddApplicationOutputResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    OutputDescriptions?: OutputDescription[];
+}
+export declare namespace AddApplicationOutputResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationOutputResponse) => any;
+}
+
+export interface S3ReferenceDataSource {
+    
+    BucketARN?: string;
+    
+    FileKey?: string;
+}
+export declare namespace S3ReferenceDataSource {
+    
+    const filterSensitiveLog: (obj: S3ReferenceDataSource) => any;
+}
+
+export interface ReferenceDataSource {
+    
+    TableName: string | undefined;
+    
+    S3ReferenceDataSource?: S3ReferenceDataSource;
+    
+    ReferenceSchema: SourceSchema | undefined;
+}
+export declare namespace ReferenceDataSource {
+    
+    const filterSensitiveLog: (obj: ReferenceDataSource) => any;
+}
+export interface AddApplicationReferenceDataSourceRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    ReferenceDataSource: ReferenceDataSource | undefined;
+}
+export declare namespace AddApplicationReferenceDataSourceRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationReferenceDataSourceRequest) => any;
+}
+
+export interface S3ReferenceDataSourceDescription {
+    
+    BucketARN: string | undefined;
+    
+    FileKey: string | undefined;
+    
+    ReferenceRoleARN?: string;
+}
+export declare namespace S3ReferenceDataSourceDescription {
+    
+    const filterSensitiveLog: (obj: S3ReferenceDataSourceDescription) => any;
+}
+
+export interface ReferenceDataSourceDescription {
+    
+    ReferenceId: string | undefined;
+    
+    TableName: string | undefined;
+    
+    S3ReferenceDataSourceDescription: S3ReferenceDataSourceDescription | undefined;
+    
+    ReferenceSchema?: SourceSchema;
+}
+export declare namespace ReferenceDataSourceDescription {
+    
+    const filterSensitiveLog: (obj: ReferenceDataSourceDescription) => any;
+}
+export interface AddApplicationReferenceDataSourceResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    ReferenceDataSourceDescriptions?: ReferenceDataSourceDescription[];
+}
+export declare namespace AddApplicationReferenceDataSourceResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationReferenceDataSourceResponse) => any;
+}
+
+export interface VpcConfiguration {
+    
+    SubnetIds: string[] | undefined;
+    
+    SecurityGroupIds: string[] | undefined;
+}
+export declare namespace VpcConfiguration {
+    
+    const filterSensitiveLog: (obj: VpcConfiguration) => any;
+}
+export interface AddApplicationVpcConfigurationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId?: number;
+    
+    VpcConfiguration: VpcConfiguration | undefined;
+    
+    ConditionalToken?: string;
+}
+export declare namespace AddApplicationVpcConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: AddApplicationVpcConfigurationRequest) => any;
+}
+
+export interface VpcConfigurationDescription {
+    
+    VpcConfigurationId: string | undefined;
+    
+    VpcId: string | undefined;
+    
+    SubnetIds: string[] | undefined;
+    
+    SecurityGroupIds: string[] | undefined;
+}
+export declare namespace VpcConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: VpcConfigurationDescription) => any;
+}
+export interface AddApplicationVpcConfigurationResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    VpcConfigurationDescription?: VpcConfigurationDescription;
+}
+export declare namespace AddApplicationVpcConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: AddApplicationVpcConfigurationResponse) => any;
+}
+
+export interface S3ContentLocation {
+    
+    BucketARN: string | undefined;
+    
+    FileKey: string | undefined;
+    
+    ObjectVersion?: string;
+}
+export declare namespace S3ContentLocation {
+    
+    const filterSensitiveLog: (obj: S3ContentLocation) => any;
+}
+
+export interface CodeContent {
+    
+    TextContent?: string;
+    
+    ZipFileContent?: Uint8Array;
+    
+    S3ContentLocation?: S3ContentLocation;
+}
+export declare namespace CodeContent {
+    
+    const filterSensitiveLog: (obj: CodeContent) => any;
+}
+export declare enum CodeContentType {
+    PLAINTEXT = "PLAINTEXT",
+    ZIPFILE = "ZIPFILE"
+}
+
+export interface ApplicationCodeConfiguration {
+    
+    CodeContent?: CodeContent;
+    
+    CodeContentType: CodeContentType | string | undefined;
+}
+export declare namespace ApplicationCodeConfiguration {
+    
+    const filterSensitiveLog: (obj: ApplicationCodeConfiguration) => any;
+}
+
+export interface S3ApplicationCodeLocationDescription {
+    
+    BucketARN: string | undefined;
+    
+    FileKey: string | undefined;
+    
+    ObjectVersion?: string;
+}
+export declare namespace S3ApplicationCodeLocationDescription {
+    
+    const filterSensitiveLog: (obj: S3ApplicationCodeLocationDescription) => any;
+}
+
+export interface CodeContentDescription {
+    
+    TextContent?: string;
+    
+    CodeMD5?: string;
+    
+    CodeSize?: number;
+    
+    S3ApplicationCodeLocationDescription?: S3ApplicationCodeLocationDescription;
+}
+export declare namespace CodeContentDescription {
+    
+    const filterSensitiveLog: (obj: CodeContentDescription) => any;
+}
+
+export interface ApplicationCodeConfigurationDescription {
+    
+    CodeContentType: CodeContentType | string | undefined;
+    
+    CodeContentDescription?: CodeContentDescription;
+}
+export declare namespace ApplicationCodeConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationCodeConfigurationDescription) => any;
+}
+
+export interface S3ContentLocationUpdate {
+    
+    BucketARNUpdate?: string;
+    
+    FileKeyUpdate?: string;
+    
+    ObjectVersionUpdate?: string;
+}
+export declare namespace S3ContentLocationUpdate {
+    
+    const filterSensitiveLog: (obj: S3ContentLocationUpdate) => any;
+}
+
+export interface CodeContentUpdate {
+    
+    TextContentUpdate?: string;
+    
+    ZipFileContentUpdate?: Uint8Array;
+    
+    S3ContentLocationUpdate?: S3ContentLocationUpdate;
+}
+export declare namespace CodeContentUpdate {
+    
+    const filterSensitiveLog: (obj: CodeContentUpdate) => any;
+}
+
+export interface ApplicationCodeConfigurationUpdate {
+    
+    CodeContentTypeUpdate?: CodeContentType | string;
+    
+    CodeContentUpdate?: CodeContentUpdate;
+}
+export declare namespace ApplicationCodeConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ApplicationCodeConfigurationUpdate) => any;
+}
+
+export interface ApplicationSnapshotConfiguration {
+    
+    SnapshotsEnabled: boolean | undefined;
+}
+export declare namespace ApplicationSnapshotConfiguration {
+    
+    const filterSensitiveLog: (obj: ApplicationSnapshotConfiguration) => any;
+}
+
+export interface PropertyGroup {
+    
+    PropertyGroupId: string | undefined;
+    
+    PropertyMap: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace PropertyGroup {
+    
+    const filterSensitiveLog: (obj: PropertyGroup) => any;
+}
+
+export interface EnvironmentProperties {
+    
+    PropertyGroups: PropertyGroup[] | undefined;
+}
+export declare namespace EnvironmentProperties {
+    
+    const filterSensitiveLog: (obj: EnvironmentProperties) => any;
+}
+export declare enum ConfigurationType {
+    CUSTOM = "CUSTOM",
+    DEFAULT = "DEFAULT"
+}
+
+export interface CheckpointConfiguration {
+    
+    ConfigurationType: ConfigurationType | string | undefined;
+    
+    CheckpointingEnabled?: boolean;
+    
+    CheckpointInterval?: number;
+    
+    MinPauseBetweenCheckpoints?: number;
+}
+export declare namespace CheckpointConfiguration {
+    
+    const filterSensitiveLog: (obj: CheckpointConfiguration) => any;
+}
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    ERROR = "ERROR",
+    INFO = "INFO",
+    WARN = "WARN"
+}
+export declare enum MetricsLevel {
+    APPLICATION = "APPLICATION",
+    OPERATOR = "OPERATOR",
+    PARALLELISM = "PARALLELISM",
+    TASK = "TASK"
+}
+
+export interface MonitoringConfiguration {
+    
+    ConfigurationType: ConfigurationType | string | undefined;
+    
+    MetricsLevel?: MetricsLevel | string;
+    
+    LogLevel?: LogLevel | string;
+}
+export declare namespace MonitoringConfiguration {
+    
+    const filterSensitiveLog: (obj: MonitoringConfiguration) => any;
+}
+
+export interface ParallelismConfiguration {
+    
+    ConfigurationType: ConfigurationType | string | undefined;
+    
+    Parallelism?: number;
+    
+    ParallelismPerKPU?: number;
+    
+    AutoScalingEnabled?: boolean;
+}
+export declare namespace ParallelismConfiguration {
+    
+    const filterSensitiveLog: (obj: ParallelismConfiguration) => any;
+}
+
+export interface FlinkApplicationConfiguration {
+    
+    CheckpointConfiguration?: CheckpointConfiguration;
+    
+    MonitoringConfiguration?: MonitoringConfiguration;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+export declare namespace FlinkApplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: FlinkApplicationConfiguration) => any;
+}
+
+export interface SqlApplicationConfiguration {
+    
+    Inputs?: Input[];
+    
+    Outputs?: Output[];
+    
+    ReferenceDataSources?: ReferenceDataSource[];
+}
+export declare namespace SqlApplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: SqlApplicationConfiguration) => any;
+}
+
+export interface GlueDataCatalogConfiguration {
+    
+    DatabaseARN: string | undefined;
+}
+export declare namespace GlueDataCatalogConfiguration {
+    
+    const filterSensitiveLog: (obj: GlueDataCatalogConfiguration) => any;
+}
+
+export interface CatalogConfiguration {
+    
+    GlueDataCatalogConfiguration: GlueDataCatalogConfiguration | undefined;
+}
+export declare namespace CatalogConfiguration {
+    
+    const filterSensitiveLog: (obj: CatalogConfiguration) => any;
+}
+export declare enum ArtifactType {
+    DEPENDENCY_JAR = "DEPENDENCY_JAR",
+    UDF = "UDF"
+}
+
+export interface MavenReference {
+    
+    GroupId: string | undefined;
+    
+    ArtifactId: string | undefined;
+    
+    Version: string | undefined;
+}
+export declare namespace MavenReference {
+    
+    const filterSensitiveLog: (obj: MavenReference) => any;
+}
+
+export interface CustomArtifactConfiguration {
+    
+    ArtifactType: ArtifactType | string | undefined;
+    
+    S3ContentLocation?: S3ContentLocation;
+    
+    MavenReference?: MavenReference;
+}
+export declare namespace CustomArtifactConfiguration {
+    
+    const filterSensitiveLog: (obj: CustomArtifactConfiguration) => any;
+}
+
+export interface S3ContentBaseLocation {
+    
+    BucketARN: string | undefined;
+    
+    BasePath?: string;
+}
+export declare namespace S3ContentBaseLocation {
+    
+    const filterSensitiveLog: (obj: S3ContentBaseLocation) => any;
+}
+
+export interface DeployAsApplicationConfiguration {
+    
+    S3ContentLocation: S3ContentBaseLocation | undefined;
+}
+export declare namespace DeployAsApplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: DeployAsApplicationConfiguration) => any;
+}
+
+export interface ZeppelinMonitoringConfiguration {
+    
+    LogLevel: LogLevel | string | undefined;
+}
+export declare namespace ZeppelinMonitoringConfiguration {
+    
+    const filterSensitiveLog: (obj: ZeppelinMonitoringConfiguration) => any;
+}
+
+export interface ZeppelinApplicationConfiguration {
+    
+    MonitoringConfiguration?: ZeppelinMonitoringConfiguration;
+    
+    CatalogConfiguration?: CatalogConfiguration;
+    
+    DeployAsApplicationConfiguration?: DeployAsApplicationConfiguration;
+    
+    CustomArtifactsConfiguration?: CustomArtifactConfiguration[];
+}
+export declare namespace ZeppelinApplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: ZeppelinApplicationConfiguration) => any;
+}
+
+export interface ApplicationConfiguration {
+    
+    SqlApplicationConfiguration?: SqlApplicationConfiguration;
+    
+    FlinkApplicationConfiguration?: FlinkApplicationConfiguration;
+    
+    EnvironmentProperties?: EnvironmentProperties;
+    
+    ApplicationCodeConfiguration?: ApplicationCodeConfiguration;
+    
+    ApplicationSnapshotConfiguration?: ApplicationSnapshotConfiguration;
+    
+    VpcConfigurations?: VpcConfiguration[];
+    
+    ZeppelinApplicationConfiguration?: ZeppelinApplicationConfiguration;
+}
+export declare namespace ApplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: ApplicationConfiguration) => any;
+}
+
+export interface ApplicationSnapshotConfigurationDescription {
+    
+    SnapshotsEnabled: boolean | undefined;
+}
+export declare namespace ApplicationSnapshotConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationSnapshotConfigurationDescription) => any;
+}
+
+export interface EnvironmentPropertyDescriptions {
+    
+    PropertyGroupDescriptions?: PropertyGroup[];
+}
+export declare namespace EnvironmentPropertyDescriptions {
+    
+    const filterSensitiveLog: (obj: EnvironmentPropertyDescriptions) => any;
+}
+
+export interface CheckpointConfigurationDescription {
+    
+    ConfigurationType?: ConfigurationType | string;
+    
+    CheckpointingEnabled?: boolean;
+    
+    CheckpointInterval?: number;
+    
+    MinPauseBetweenCheckpoints?: number;
+}
+export declare namespace CheckpointConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: CheckpointConfigurationDescription) => any;
+}
+
+export interface MonitoringConfigurationDescription {
+    
+    ConfigurationType?: ConfigurationType | string;
+    
+    MetricsLevel?: MetricsLevel | string;
+    
+    LogLevel?: LogLevel | string;
+}
+export declare namespace MonitoringConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: MonitoringConfigurationDescription) => any;
+}
+
+export interface ParallelismConfigurationDescription {
+    
+    ConfigurationType?: ConfigurationType | string;
+    
+    Parallelism?: number;
+    
+    ParallelismPerKPU?: number;
+    
+    CurrentParallelism?: number;
+    
+    AutoScalingEnabled?: boolean;
+}
+export declare namespace ParallelismConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ParallelismConfigurationDescription) => any;
+}
+
+export interface FlinkApplicationConfigurationDescription {
+    
+    CheckpointConfigurationDescription?: CheckpointConfigurationDescription;
+    
+    MonitoringConfigurationDescription?: MonitoringConfigurationDescription;
+    
+    ParallelismConfigurationDescription?: ParallelismConfigurationDescription;
+    
+    JobPlanDescription?: string;
+}
+export declare namespace FlinkApplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: FlinkApplicationConfigurationDescription) => any;
+}
+export declare enum ApplicationRestoreType {
+    RESTORE_FROM_CUSTOM_SNAPSHOT = "RESTORE_FROM_CUSTOM_SNAPSHOT",
+    RESTORE_FROM_LATEST_SNAPSHOT = "RESTORE_FROM_LATEST_SNAPSHOT",
+    SKIP_RESTORE_FROM_SNAPSHOT = "SKIP_RESTORE_FROM_SNAPSHOT"
+}
+
+export interface ApplicationRestoreConfiguration {
+    
+    ApplicationRestoreType: ApplicationRestoreType | string | undefined;
+    
+    SnapshotName?: string;
+}
+export declare namespace ApplicationRestoreConfiguration {
+    
+    const filterSensitiveLog: (obj: ApplicationRestoreConfiguration) => any;
+}
+
+export interface FlinkRunConfiguration {
+    
+    AllowNonRestoredState?: boolean;
+}
+export declare namespace FlinkRunConfiguration {
+    
+    const filterSensitiveLog: (obj: FlinkRunConfiguration) => any;
+}
+
+export interface RunConfigurationDescription {
+    
+    ApplicationRestoreConfigurationDescription?: ApplicationRestoreConfiguration;
+    
+    FlinkRunConfigurationDescription?: FlinkRunConfiguration;
+}
+export declare namespace RunConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: RunConfigurationDescription) => any;
+}
+
+export interface SqlApplicationConfigurationDescription {
+    
+    InputDescriptions?: InputDescription[];
+    
+    OutputDescriptions?: OutputDescription[];
+    
+    ReferenceDataSourceDescriptions?: ReferenceDataSourceDescription[];
+}
+export declare namespace SqlApplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: SqlApplicationConfigurationDescription) => any;
+}
+
+export interface GlueDataCatalogConfigurationDescription {
+    
+    DatabaseARN: string | undefined;
+}
+export declare namespace GlueDataCatalogConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: GlueDataCatalogConfigurationDescription) => any;
+}
+
+export interface CatalogConfigurationDescription {
+    
+    GlueDataCatalogConfigurationDescription: GlueDataCatalogConfigurationDescription | undefined;
+}
+export declare namespace CatalogConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: CatalogConfigurationDescription) => any;
+}
+
+export interface CustomArtifactConfigurationDescription {
+    
+    ArtifactType?: ArtifactType | string;
+    
+    S3ContentLocationDescription?: S3ContentLocation;
+    
+    MavenReferenceDescription?: MavenReference;
+}
+export declare namespace CustomArtifactConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: CustomArtifactConfigurationDescription) => any;
+}
+
+export interface S3ContentBaseLocationDescription {
+    
+    BucketARN: string | undefined;
+    
+    BasePath?: string;
+}
+export declare namespace S3ContentBaseLocationDescription {
+    
+    const filterSensitiveLog: (obj: S3ContentBaseLocationDescription) => any;
+}
+
+export interface DeployAsApplicationConfigurationDescription {
+    
+    S3ContentLocationDescription: S3ContentBaseLocationDescription | undefined;
+}
+export declare namespace DeployAsApplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: DeployAsApplicationConfigurationDescription) => any;
+}
+
+export interface ZeppelinMonitoringConfigurationDescription {
+    
+    LogLevel?: LogLevel | string;
+}
+export declare namespace ZeppelinMonitoringConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ZeppelinMonitoringConfigurationDescription) => any;
+}
+
+export interface ZeppelinApplicationConfigurationDescription {
+    
+    MonitoringConfigurationDescription: ZeppelinMonitoringConfigurationDescription | undefined;
+    
+    CatalogConfigurationDescription?: CatalogConfigurationDescription;
+    
+    DeployAsApplicationConfigurationDescription?: DeployAsApplicationConfigurationDescription;
+    
+    CustomArtifactsConfigurationDescription?: CustomArtifactConfigurationDescription[];
+}
+export declare namespace ZeppelinApplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ZeppelinApplicationConfigurationDescription) => any;
+}
+
+export interface ApplicationConfigurationDescription {
+    
+    SqlApplicationConfigurationDescription?: SqlApplicationConfigurationDescription;
+    
+    ApplicationCodeConfigurationDescription?: ApplicationCodeConfigurationDescription;
+    
+    RunConfigurationDescription?: RunConfigurationDescription;
+    
+    FlinkApplicationConfigurationDescription?: FlinkApplicationConfigurationDescription;
+    
+    EnvironmentPropertyDescriptions?: EnvironmentPropertyDescriptions;
+    
+    ApplicationSnapshotConfigurationDescription?: ApplicationSnapshotConfigurationDescription;
+    
+    VpcConfigurationDescriptions?: VpcConfigurationDescription[];
+    
+    ZeppelinApplicationConfigurationDescription?: ZeppelinApplicationConfigurationDescription;
+}
+export declare namespace ApplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationConfigurationDescription) => any;
+}
+
+export interface ApplicationSnapshotConfigurationUpdate {
+    
+    SnapshotsEnabledUpdate: boolean | undefined;
+}
+export declare namespace ApplicationSnapshotConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ApplicationSnapshotConfigurationUpdate) => any;
+}
+
+export interface EnvironmentPropertyUpdates {
+    
+    PropertyGroups: PropertyGroup[] | undefined;
+}
+export declare namespace EnvironmentPropertyUpdates {
+    
+    const filterSensitiveLog: (obj: EnvironmentPropertyUpdates) => any;
+}
+
+export interface CheckpointConfigurationUpdate {
+    
+    ConfigurationTypeUpdate?: ConfigurationType | string;
+    
+    CheckpointingEnabledUpdate?: boolean;
+    
+    CheckpointIntervalUpdate?: number;
+    
+    MinPauseBetweenCheckpointsUpdate?: number;
+}
+export declare namespace CheckpointConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: CheckpointConfigurationUpdate) => any;
+}
+
+export interface MonitoringConfigurationUpdate {
+    
+    ConfigurationTypeUpdate?: ConfigurationType | string;
+    
+    MetricsLevelUpdate?: MetricsLevel | string;
+    
+    LogLevelUpdate?: LogLevel | string;
+}
+export declare namespace MonitoringConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: MonitoringConfigurationUpdate) => any;
+}
+
+export interface ParallelismConfigurationUpdate {
+    
+    ConfigurationTypeUpdate?: ConfigurationType | string;
+    
+    ParallelismUpdate?: number;
+    
+    ParallelismPerKPUUpdate?: number;
+    
+    AutoScalingEnabledUpdate?: boolean;
+}
+export declare namespace ParallelismConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ParallelismConfigurationUpdate) => any;
+}
+
+export interface FlinkApplicationConfigurationUpdate {
+    
+    CheckpointConfigurationUpdate?: CheckpointConfigurationUpdate;
+    
+    MonitoringConfigurationUpdate?: MonitoringConfigurationUpdate;
+    
+    ParallelismConfigurationUpdate?: ParallelismConfigurationUpdate;
+}
+export declare namespace FlinkApplicationConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: FlinkApplicationConfigurationUpdate) => any;
+}
+
+export interface InputParallelismUpdate {
+    
+    CountUpdate: number | undefined;
+}
+export declare namespace InputParallelismUpdate {
+    
+    const filterSensitiveLog: (obj: InputParallelismUpdate) => any;
+}
+
+export interface InputLambdaProcessorUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace InputLambdaProcessorUpdate {
+    
+    const filterSensitiveLog: (obj: InputLambdaProcessorUpdate) => any;
+}
+
+export interface InputProcessingConfigurationUpdate {
+    
+    InputLambdaProcessorUpdate: InputLambdaProcessorUpdate | undefined;
+}
+export declare namespace InputProcessingConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: InputProcessingConfigurationUpdate) => any;
+}
+
+export interface InputSchemaUpdate {
+    
+    RecordFormatUpdate?: RecordFormat;
+    
+    RecordEncodingUpdate?: string;
+    
+    RecordColumnUpdates?: RecordColumn[];
+}
+export declare namespace InputSchemaUpdate {
+    
+    const filterSensitiveLog: (obj: InputSchemaUpdate) => any;
+}
+
+export interface KinesisFirehoseInputUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace KinesisFirehoseInputUpdate {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseInputUpdate) => any;
+}
+
+export interface KinesisStreamsInputUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace KinesisStreamsInputUpdate {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsInputUpdate) => any;
+}
+
+export interface InputUpdate {
+    
+    InputId: string | undefined;
+    
+    NamePrefixUpdate?: string;
+    
+    InputProcessingConfigurationUpdate?: InputProcessingConfigurationUpdate;
+    
+    KinesisStreamsInputUpdate?: KinesisStreamsInputUpdate;
+    
+    KinesisFirehoseInputUpdate?: KinesisFirehoseInputUpdate;
+    
+    InputSchemaUpdate?: InputSchemaUpdate;
+    
+    InputParallelismUpdate?: InputParallelismUpdate;
+}
+export declare namespace InputUpdate {
+    
+    const filterSensitiveLog: (obj: InputUpdate) => any;
+}
+
+export interface KinesisFirehoseOutputUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace KinesisFirehoseOutputUpdate {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseOutputUpdate) => any;
+}
+
+export interface KinesisStreamsOutputUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace KinesisStreamsOutputUpdate {
+    
+    const filterSensitiveLog: (obj: KinesisStreamsOutputUpdate) => any;
+}
+
+export interface LambdaOutputUpdate {
+    
+    ResourceARNUpdate: string | undefined;
+}
+export declare namespace LambdaOutputUpdate {
+    
+    const filterSensitiveLog: (obj: LambdaOutputUpdate) => any;
+}
+
+export interface OutputUpdate {
+    
+    OutputId: string | undefined;
+    
+    NameUpdate?: string;
+    
+    KinesisStreamsOutputUpdate?: KinesisStreamsOutputUpdate;
+    
+    KinesisFirehoseOutputUpdate?: KinesisFirehoseOutputUpdate;
+    
+    LambdaOutputUpdate?: LambdaOutputUpdate;
+    
+    DestinationSchemaUpdate?: DestinationSchema;
+}
+export declare namespace OutputUpdate {
+    
+    const filterSensitiveLog: (obj: OutputUpdate) => any;
+}
+
+export interface S3ReferenceDataSourceUpdate {
+    
+    BucketARNUpdate?: string;
+    
+    FileKeyUpdate?: string;
+}
+export declare namespace S3ReferenceDataSourceUpdate {
+    
+    const filterSensitiveLog: (obj: S3ReferenceDataSourceUpdate) => any;
+}
+
+export interface ReferenceDataSourceUpdate {
+    
+    ReferenceId: string | undefined;
+    
+    TableNameUpdate?: string;
+    
+    S3ReferenceDataSourceUpdate?: S3ReferenceDataSourceUpdate;
+    
+    ReferenceSchemaUpdate?: SourceSchema;
+}
+export declare namespace ReferenceDataSourceUpdate {
+    
+    const filterSensitiveLog: (obj: ReferenceDataSourceUpdate) => any;
+}
+
+export interface SqlApplicationConfigurationUpdate {
+    
+    InputUpdates?: InputUpdate[];
+    
+    OutputUpdates?: OutputUpdate[];
+    
+    ReferenceDataSourceUpdates?: ReferenceDataSourceUpdate[];
+}
+export declare namespace SqlApplicationConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: SqlApplicationConfigurationUpdate) => any;
+}
+
+export interface VpcConfigurationUpdate {
+    
+    VpcConfigurationId: string | undefined;
+    
+    SubnetIdUpdates?: string[];
+    
+    SecurityGroupIdUpdates?: string[];
+}
+export declare namespace VpcConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: VpcConfigurationUpdate) => any;
+}
+
+export interface GlueDataCatalogConfigurationUpdate {
+    
+    DatabaseARNUpdate: string | undefined;
+}
+export declare namespace GlueDataCatalogConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: GlueDataCatalogConfigurationUpdate) => any;
+}
+
+export interface CatalogConfigurationUpdate {
+    
+    GlueDataCatalogConfigurationUpdate: GlueDataCatalogConfigurationUpdate | undefined;
+}
+export declare namespace CatalogConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: CatalogConfigurationUpdate) => any;
+}
+
+export interface S3ContentBaseLocationUpdate {
+    
+    BucketARNUpdate?: string;
+    
+    BasePathUpdate?: string;
+}
+export declare namespace S3ContentBaseLocationUpdate {
+    
+    const filterSensitiveLog: (obj: S3ContentBaseLocationUpdate) => any;
+}
+
+export interface DeployAsApplicationConfigurationUpdate {
+    
+    S3ContentLocationUpdate?: S3ContentBaseLocationUpdate;
+}
+export declare namespace DeployAsApplicationConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: DeployAsApplicationConfigurationUpdate) => any;
+}
+
+export interface ZeppelinMonitoringConfigurationUpdate {
+    
+    LogLevelUpdate: LogLevel | string | undefined;
+}
+export declare namespace ZeppelinMonitoringConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ZeppelinMonitoringConfigurationUpdate) => any;
+}
+
+export interface ZeppelinApplicationConfigurationUpdate {
+    
+    MonitoringConfigurationUpdate?: ZeppelinMonitoringConfigurationUpdate;
+    
+    CatalogConfigurationUpdate?: CatalogConfigurationUpdate;
+    
+    DeployAsApplicationConfigurationUpdate?: DeployAsApplicationConfigurationUpdate;
+    
+    CustomArtifactsConfigurationUpdate?: CustomArtifactConfiguration[];
+}
+export declare namespace ZeppelinApplicationConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ZeppelinApplicationConfigurationUpdate) => any;
+}
+
+export interface ApplicationConfigurationUpdate {
+    
+    SqlApplicationConfigurationUpdate?: SqlApplicationConfigurationUpdate;
+    
+    ApplicationCodeConfigurationUpdate?: ApplicationCodeConfigurationUpdate;
+    
+    FlinkApplicationConfigurationUpdate?: FlinkApplicationConfigurationUpdate;
+    
+    EnvironmentPropertyUpdates?: EnvironmentPropertyUpdates;
+    
+    ApplicationSnapshotConfigurationUpdate?: ApplicationSnapshotConfigurationUpdate;
+    
+    VpcConfigurationUpdates?: VpcConfigurationUpdate[];
+    
+    ZeppelinApplicationConfigurationUpdate?: ZeppelinApplicationConfigurationUpdate;
+}
+export declare namespace ApplicationConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ApplicationConfigurationUpdate) => any;
+}
+
+export interface ApplicationMaintenanceConfigurationDescription {
+    
+    ApplicationMaintenanceWindowStartTime: string | undefined;
+    
+    ApplicationMaintenanceWindowEndTime: string | undefined;
+}
+export declare namespace ApplicationMaintenanceConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationMaintenanceConfigurationDescription) => any;
+}
+export declare enum ApplicationMode {
+    INTERACTIVE = "INTERACTIVE",
+    STREAMING = "STREAMING"
+}
+export declare enum ApplicationStatus {
+    AUTOSCALING = "AUTOSCALING",
+    DELETING = "DELETING",
+    FORCE_STOPPING = "FORCE_STOPPING",
+    MAINTENANCE = "MAINTENANCE",
+    READY = "READY",
+    ROLLED_BACK = "ROLLED_BACK",
+    ROLLING_BACK = "ROLLING_BACK",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPING = "STOPPING",
+    UPDATING = "UPDATING"
+}
+export declare enum RuntimeEnvironment {
+    FLINK_1_11 = "FLINK-1_11",
+    FLINK_1_13 = "FLINK-1_13",
+    FLINK_1_6 = "FLINK-1_6",
+    FLINK_1_8 = "FLINK-1_8",
+    SQL_1_0 = "SQL-1_0",
+    ZEPPELIN_FLINK_1_0 = "ZEPPELIN-FLINK-1_0",
+    ZEPPELIN_FLINK_2_0 = "ZEPPELIN-FLINK-2_0"
+}
+
+export interface ApplicationDetail {
+    
+    ApplicationARN: string | undefined;
+    
+    ApplicationDescription?: string;
+    
+    ApplicationName: string | undefined;
+    
+    RuntimeEnvironment: RuntimeEnvironment | string | undefined;
+    
+    ServiceExecutionRole?: string;
+    
+    ApplicationStatus: ApplicationStatus | string | undefined;
+    
+    ApplicationVersionId: number | undefined;
+    
+    CreateTimestamp?: Date;
+    
+    LastUpdateTimestamp?: Date;
+    
+    ApplicationConfigurationDescription?: ApplicationConfigurationDescription;
+    
+    CloudWatchLoggingOptionDescriptions?: CloudWatchLoggingOptionDescription[];
+    
+    ApplicationMaintenanceConfigurationDescription?: ApplicationMaintenanceConfigurationDescription;
+    
+    ApplicationVersionUpdatedFrom?: number;
+    
+    ApplicationVersionRolledBackFrom?: number;
+    
+    ConditionalToken?: string;
+    
+    ApplicationVersionRolledBackTo?: number;
+    
+    ApplicationMode?: ApplicationMode | string;
+}
+export declare namespace ApplicationDetail {
+    
+    const filterSensitiveLog: (obj: ApplicationDetail) => any;
+}
+
+export interface ApplicationMaintenanceConfigurationUpdate {
+    
+    ApplicationMaintenanceWindowStartTimeUpdate: string | undefined;
+}
+export declare namespace ApplicationMaintenanceConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: ApplicationMaintenanceConfigurationUpdate) => any;
+}
+
+export interface ApplicationSummary {
+    
+    ApplicationName: string | undefined;
+    
+    ApplicationARN: string | undefined;
+    
+    ApplicationStatus: ApplicationStatus | string | undefined;
+    
+    ApplicationVersionId: number | undefined;
+    
+    RuntimeEnvironment: RuntimeEnvironment | string | undefined;
+    
+    ApplicationMode?: ApplicationMode | string;
+}
+export declare namespace ApplicationSummary {
+    
+    const filterSensitiveLog: (obj: ApplicationSummary) => any;
+}
+
+export interface ApplicationVersionSummary {
+    
+    ApplicationVersionId: number | undefined;
+    
+    ApplicationStatus: ApplicationStatus | string | undefined;
+}
+export declare namespace ApplicationVersionSummary {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionSummary) => any;
+}
+
+export interface CloudWatchLoggingOptionUpdate {
+    
+    CloudWatchLoggingOptionId: string | undefined;
+    
+    LogStreamARNUpdate?: string;
+}
+export declare namespace CloudWatchLoggingOptionUpdate {
+    
+    const filterSensitiveLog: (obj: CloudWatchLoggingOptionUpdate) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    ApplicationDescription?: string;
+    
+    RuntimeEnvironment: RuntimeEnvironment | string | undefined;
+    
+    ServiceExecutionRole: string | undefined;
+    
+    ApplicationConfiguration?: ApplicationConfiguration;
+    
+    CloudWatchLoggingOptions?: CloudWatchLoggingOption[];
+    
+    Tags?: Tag[];
+    
+    ApplicationMode?: ApplicationMode | string;
+}
+export declare namespace CreateApplicationRequest {
+    
+    const filterSensitiveLog: (obj: CreateApplicationRequest) => any;
+}
+export interface CreateApplicationResponse {
+    
+    ApplicationDetail: ApplicationDetail | undefined;
+}
+export declare namespace CreateApplicationResponse {
+    
+    const filterSensitiveLog: (obj: CreateApplicationResponse) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface UnsupportedOperationException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedOperationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum UrlType {
+    FLINK_DASHBOARD_URL = "FLINK_DASHBOARD_URL",
+    ZEPPELIN_UI_URL = "ZEPPELIN_UI_URL"
+}
+export interface CreateApplicationPresignedUrlRequest {
+    
+    ApplicationName: string | undefined;
+    
+    UrlType: UrlType | string | undefined;
+    
+    SessionExpirationDurationInSeconds?: number;
+}
+export declare namespace CreateApplicationPresignedUrlRequest {
+    
+    const filterSensitiveLog: (obj: CreateApplicationPresignedUrlRequest) => any;
+}
+export interface CreateApplicationPresignedUrlResponse {
+    
+    AuthorizedUrl?: string;
+}
+export declare namespace CreateApplicationPresignedUrlResponse {
+    
+    const filterSensitiveLog: (obj: CreateApplicationPresignedUrlResponse) => any;
+}
+export interface CreateApplicationSnapshotRequest {
+    
+    ApplicationName: string | undefined;
+    
+    SnapshotName: string | undefined;
+}
+export declare namespace CreateApplicationSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: CreateApplicationSnapshotRequest) => any;
+}
+export interface CreateApplicationSnapshotResponse {
+}
+export declare namespace CreateApplicationSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: CreateApplicationSnapshotResponse) => any;
+}
+export interface DeleteApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CreateTimestamp: Date | undefined;
+}
+export declare namespace DeleteApplicationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationRequest) => any;
+}
+export interface DeleteApplicationResponse {
+}
+export declare namespace DeleteApplicationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationResponse) => any;
+}
+export interface DeleteApplicationCloudWatchLoggingOptionRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId?: number;
+    
+    CloudWatchLoggingOptionId: string | undefined;
+    
+    ConditionalToken?: string;
+}
+export declare namespace DeleteApplicationCloudWatchLoggingOptionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationCloudWatchLoggingOptionRequest) => any;
+}
+export interface DeleteApplicationCloudWatchLoggingOptionResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+    
+    CloudWatchLoggingOptionDescriptions?: CloudWatchLoggingOptionDescription[];
+}
+export declare namespace DeleteApplicationCloudWatchLoggingOptionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationCloudWatchLoggingOptionResponse) => any;
+}
+export interface DeleteApplicationInputProcessingConfigurationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    InputId: string | undefined;
+}
+export declare namespace DeleteApplicationInputProcessingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationInputProcessingConfigurationRequest) => any;
+}
+export interface DeleteApplicationInputProcessingConfigurationResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+}
+export declare namespace DeleteApplicationInputProcessingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationInputProcessingConfigurationResponse) => any;
+}
+export interface DeleteApplicationOutputRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    OutputId: string | undefined;
+}
+export declare namespace DeleteApplicationOutputRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationOutputRequest) => any;
+}
+export interface DeleteApplicationOutputResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+}
+export declare namespace DeleteApplicationOutputResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationOutputResponse) => any;
+}
+export interface DeleteApplicationReferenceDataSourceRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+    
+    ReferenceId: string | undefined;
+}
+export declare namespace DeleteApplicationReferenceDataSourceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationReferenceDataSourceRequest) => any;
+}
+export interface DeleteApplicationReferenceDataSourceResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+}
+export declare namespace DeleteApplicationReferenceDataSourceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationReferenceDataSourceResponse) => any;
+}
+export interface DeleteApplicationSnapshotRequest {
+    
+    ApplicationName: string | undefined;
+    
+    SnapshotName: string | undefined;
+    
+    SnapshotCreationTimestamp: Date | undefined;
+}
+export declare namespace DeleteApplicationSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationSnapshotRequest) => any;
+}
+export interface DeleteApplicationSnapshotResponse {
+}
+export declare namespace DeleteApplicationSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationSnapshotResponse) => any;
+}
+export interface DeleteApplicationVpcConfigurationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId?: number;
+    
+    VpcConfigurationId: string | undefined;
+    
+    ConditionalToken?: string;
+}
+export declare namespace DeleteApplicationVpcConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationVpcConfigurationRequest) => any;
+}
+export interface DeleteApplicationVpcConfigurationResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationVersionId?: number;
+}
+export declare namespace DeleteApplicationVpcConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationVpcConfigurationResponse) => any;
+}
+export interface DescribeApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    IncludeAdditionalDetails?: boolean;
+}
+export declare namespace DescribeApplicationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationRequest) => any;
+}
+export interface DescribeApplicationResponse {
+    
+    ApplicationDetail: ApplicationDetail | undefined;
+}
+export declare namespace DescribeApplicationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationResponse) => any;
+}
+export interface DescribeApplicationSnapshotRequest {
+    
+    ApplicationName: string | undefined;
+    
+    SnapshotName: string | undefined;
+}
+export declare namespace DescribeApplicationSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationSnapshotRequest) => any;
+}
+export declare enum SnapshotStatus {
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    READY = "READY"
+}
+
+export interface SnapshotDetails {
+    
+    SnapshotName: string | undefined;
+    
+    SnapshotStatus: SnapshotStatus | string | undefined;
+    
+    ApplicationVersionId: number | undefined;
+    
+    SnapshotCreationTimestamp?: Date;
+}
+export declare namespace SnapshotDetails {
+    
+    const filterSensitiveLog: (obj: SnapshotDetails) => any;
+}
+export interface DescribeApplicationSnapshotResponse {
+    
+    SnapshotDetails: SnapshotDetails | undefined;
+}
+export declare namespace DescribeApplicationSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationSnapshotResponse) => any;
+}
+export interface DescribeApplicationVersionRequest {
+    
+    ApplicationName: string | undefined;
+    
+    ApplicationVersionId: number | undefined;
+}
+export declare namespace DescribeApplicationVersionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationVersionRequest) => any;
+}
+export interface DescribeApplicationVersionResponse {
+    
+    ApplicationVersionDetail?: ApplicationDetail;
+}
+export declare namespace DescribeApplicationVersionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationVersionResponse) => any;
+}
+
+export interface S3Configuration {
+    
+    BucketARN: string | undefined;
+    
+    FileKey: string | undefined;
+}
+export declare namespace S3Configuration {
+    
+    const filterSensitiveLog: (obj: S3Configuration) => any;
+}
+export interface DiscoverInputSchemaRequest {
+    
+    ResourceARN?: string;
+    
+    ServiceExecutionRole: string | undefined;
+    
+    InputStartingPositionConfiguration?: InputStartingPositionConfiguration;
+    
+    S3Configuration?: S3Configuration;
+    
+    InputProcessingConfiguration?: InputProcessingConfiguration;
+}
+export declare namespace DiscoverInputSchemaRequest {
+    
+    const filterSensitiveLog: (obj: DiscoverInputSchemaRequest) => any;
+}
+export interface DiscoverInputSchemaResponse {
+    
+    InputSchema?: SourceSchema;
+    
+    ParsedInputRecords?: string[][];
+    
+    ProcessedInputRecords?: string[];
+    
+    RawInputRecords?: string[];
+}
+export declare namespace DiscoverInputSchemaResponse {
+    
+    const filterSensitiveLog: (obj: DiscoverInputSchemaResponse) => any;
+}
+
+export interface ResourceProvisionedThroughputExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceProvisionedThroughputExceededException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    Message?: string;
+}
+
+export interface UnableToDetectSchemaException extends __SmithyException, $MetadataBearer {
+    name: "UnableToDetectSchemaException";
+    $fault: "client";
+    Message?: string;
+    
+    RawInputRecords?: string[];
+    
+    ProcessedInputRecords?: string[];
+}
+export interface ListApplicationsRequest {
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationsRequest {
+    
+    const filterSensitiveLog: (obj: ListApplicationsRequest) => any;
+}
+export interface ListApplicationsResponse {
+    
+    ApplicationSummaries: ApplicationSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationsResponse {
+    
+    const filterSensitiveLog: (obj: ListApplicationsResponse) => any;
+}
+export interface ListApplicationSnapshotsRequest {
+    
+    ApplicationName: string | undefined;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: ListApplicationSnapshotsRequest) => any;
+}
+export interface ListApplicationSnapshotsResponse {
+    
+    SnapshotSummaries?: SnapshotDetails[];
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationSnapshotsResponse {
+    
+    const filterSensitiveLog: (obj: ListApplicationSnapshotsResponse) => any;
+}
+export interface ListApplicationVersionsRequest {
+    
+    ApplicationName: string | undefined;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListApplicationVersionsRequest) => any;
+}
+export interface ListApplicationVersionsResponse {
+    
+    ApplicationVersionSummaries?: ApplicationVersionSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListApplicationVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListApplicationVersionsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface RollbackApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId: number | undefined;
+}
+export declare namespace RollbackApplicationRequest {
+    
+    const filterSensitiveLog: (obj: RollbackApplicationRequest) => any;
+}
+export interface RollbackApplicationResponse {
+    
+    ApplicationDetail: ApplicationDetail | undefined;
+}
+export declare namespace RollbackApplicationResponse {
+    
+    const filterSensitiveLog: (obj: RollbackApplicationResponse) => any;
+}
+
+export interface SqlRunConfiguration {
+    
+    InputId: string | undefined;
+    
+    InputStartingPositionConfiguration: InputStartingPositionConfiguration | undefined;
+}
+export declare namespace SqlRunConfiguration {
+    
+    const filterSensitiveLog: (obj: SqlRunConfiguration) => any;
+}
+
+export interface RunConfiguration {
+    
+    FlinkRunConfiguration?: FlinkRunConfiguration;
+    
+    SqlRunConfigurations?: SqlRunConfiguration[];
+    
+    ApplicationRestoreConfiguration?: ApplicationRestoreConfiguration;
+}
+export declare namespace RunConfiguration {
+    
+    const filterSensitiveLog: (obj: RunConfiguration) => any;
+}
+export interface StartApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    RunConfiguration?: RunConfiguration;
+}
+export declare namespace StartApplicationRequest {
+    
+    const filterSensitiveLog: (obj: StartApplicationRequest) => any;
+}
+export interface StartApplicationResponse {
+}
+export declare namespace StartApplicationResponse {
+    
+    const filterSensitiveLog: (obj: StartApplicationResponse) => any;
+}
+export interface StopApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    Force?: boolean;
+}
+export declare namespace StopApplicationRequest {
+    
+    const filterSensitiveLog: (obj: StopApplicationRequest) => any;
+}
+export interface StopApplicationResponse {
+}
+export declare namespace StopApplicationResponse {
+    
+    const filterSensitiveLog: (obj: StopApplicationResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    Tags: Tag[] | 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 RunConfigurationUpdate {
+    
+    FlinkRunConfiguration?: FlinkRunConfiguration;
+    
+    ApplicationRestoreConfiguration?: ApplicationRestoreConfiguration;
+}
+export declare namespace RunConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: RunConfigurationUpdate) => any;
+}
+export interface UpdateApplicationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    CurrentApplicationVersionId?: number;
+    
+    ApplicationConfigurationUpdate?: ApplicationConfigurationUpdate;
+    
+    ServiceExecutionRoleUpdate?: string;
+    
+    RunConfigurationUpdate?: RunConfigurationUpdate;
+    
+    CloudWatchLoggingOptionUpdates?: CloudWatchLoggingOptionUpdate[];
+    
+    ConditionalToken?: string;
+}
+export declare namespace UpdateApplicationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationRequest) => any;
+}
+export interface UpdateApplicationResponse {
+    
+    ApplicationDetail: ApplicationDetail | undefined;
+}
+export declare namespace UpdateApplicationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationResponse) => any;
+}
+export interface UpdateApplicationMaintenanceConfigurationRequest {
+    
+    ApplicationName: string | undefined;
+    
+    ApplicationMaintenanceConfigurationUpdate: ApplicationMaintenanceConfigurationUpdate | undefined;
+}
+export declare namespace UpdateApplicationMaintenanceConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationMaintenanceConfigurationRequest) => any;
+}
+export interface UpdateApplicationMaintenanceConfigurationResponse {
+    
+    ApplicationARN?: string;
+    
+    ApplicationMaintenanceConfigurationDescription?: ApplicationMaintenanceConfigurationDescription;
+}
+export declare namespace UpdateApplicationMaintenanceConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationMaintenanceConfigurationResponse) => any;
+}