@aws-sdk/client-glue 3.933.0 → 3.935.0

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

@@ -0,0 +1,1918 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const AdditionalOptionKeys: {
+    readonly CacheOption: "performanceTuning.caching";
+    readonly CompositeOption: "compositeRuleEvaluation.method";
+    readonly ObservationsOption: "observations.scope";
+};
+/**
+ * @public
+ */
+export type AdditionalOptionKeys = (typeof AdditionalOptionKeys)[keyof typeof AdditionalOptionKeys];
+/**
+ * @public
+ * @enum
+ */
+export declare const AggFunction: {
+    readonly avg: "avg";
+    readonly count: "count";
+    readonly countDistinct: "countDistinct";
+    readonly first: "first";
+    readonly kurtosis: "kurtosis";
+    readonly last: "last";
+    readonly max: "max";
+    readonly min: "min";
+    readonly skewness: "skewness";
+    readonly stddev_pop: "stddev_pop";
+    readonly stddev_samp: "stddev_samp";
+    readonly sum: "sum";
+    readonly sumDistinct: "sumDistinct";
+    readonly var_pop: "var_pop";
+    readonly var_samp: "var_samp";
+};
+/**
+ * @public
+ */
+export type AggFunction = (typeof AggFunction)[keyof typeof AggFunction];
+/**
+ * @public
+ * @enum
+ */
+export declare const AllowFullTableExternalDataAccessEnum: {
+    readonly False: "False";
+    readonly True: "True";
+};
+/**
+ * @public
+ */
+export type AllowFullTableExternalDataAccessEnum = (typeof AllowFullTableExternalDataAccessEnum)[keyof typeof AllowFullTableExternalDataAccessEnum];
+/**
+ * @public
+ * @enum
+ */
+export declare const InclusionAnnotationValue: {
+    readonly EXCLUDE: "EXCLUDE";
+    readonly INCLUDE: "INCLUDE";
+};
+/**
+ * @public
+ */
+export type InclusionAnnotationValue = (typeof InclusionAnnotationValue)[keyof typeof InclusionAnnotationValue];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataOperation: {
+    readonly READ: "READ";
+    readonly WRITE: "WRITE";
+};
+/**
+ * @public
+ */
+export type DataOperation = (typeof DataOperation)[keyof typeof DataOperation];
+/**
+ * @public
+ * @enum
+ */
+export declare const PropertyType: {
+    readonly READ_ONLY: "READ_ONLY";
+    readonly SECRET: "SECRET";
+    readonly SECRET_OR_USER_INPUT: "SECRET_OR_USER_INPUT";
+    readonly UNUSED: "UNUSED";
+    readonly USER_INPUT: "USER_INPUT";
+};
+/**
+ * @public
+ */
+export type PropertyType = (typeof PropertyType)[keyof typeof PropertyType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AuthenticationType: {
+    readonly BASIC: "BASIC";
+    readonly CUSTOM: "CUSTOM";
+    readonly IAM: "IAM";
+    readonly OAUTH2: "OAUTH2";
+};
+/**
+ * @public
+ */
+export type AuthenticationType = (typeof AuthenticationType)[keyof typeof AuthenticationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const OAuth2GrantType: {
+    readonly AUTHORIZATION_CODE: "AUTHORIZATION_CODE";
+    readonly CLIENT_CREDENTIALS: "CLIENT_CREDENTIALS";
+    readonly JWT_BEARER: "JWT_BEARER";
+};
+/**
+ * @public
+ */
+export type OAuth2GrantType = (typeof OAuth2GrantType)[keyof typeof OAuth2GrantType];
+/**
+ * @public
+ * @enum
+ */
+export declare const BlueprintStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATING: "CREATING";
+    readonly FAILED: "FAILED";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type BlueprintStatus = (typeof BlueprintStatus)[keyof typeof BlueprintStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const LastCrawlStatus: {
+    readonly CANCELLED: "CANCELLED";
+    readonly FAILED: "FAILED";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type LastCrawlStatus = (typeof LastCrawlStatus)[keyof typeof LastCrawlStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CrawlerLineageSettings: {
+    readonly DISABLE: "DISABLE";
+    readonly ENABLE: "ENABLE";
+};
+/**
+ * @public
+ */
+export type CrawlerLineageSettings = (typeof CrawlerLineageSettings)[keyof typeof CrawlerLineageSettings];
+/**
+ * @public
+ * @enum
+ */
+export declare const RecrawlBehavior: {
+    readonly CRAWL_EVENT_MODE: "CRAWL_EVENT_MODE";
+    readonly CRAWL_EVERYTHING: "CRAWL_EVERYTHING";
+    readonly CRAWL_NEW_FOLDERS_ONLY: "CRAWL_NEW_FOLDERS_ONLY";
+};
+/**
+ * @public
+ */
+export type RecrawlBehavior = (typeof RecrawlBehavior)[keyof typeof RecrawlBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScheduleState: {
+    readonly NOT_SCHEDULED: "NOT_SCHEDULED";
+    readonly SCHEDULED: "SCHEDULED";
+    readonly TRANSITIONING: "TRANSITIONING";
+};
+/**
+ * @public
+ */
+export type ScheduleState = (typeof ScheduleState)[keyof typeof ScheduleState];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeleteBehavior: {
+    readonly DELETE_FROM_DATABASE: "DELETE_FROM_DATABASE";
+    readonly DEPRECATE_IN_DATABASE: "DEPRECATE_IN_DATABASE";
+    readonly LOG: "LOG";
+};
+/**
+ * @public
+ */
+export type DeleteBehavior = (typeof DeleteBehavior)[keyof typeof DeleteBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdateBehavior: {
+    readonly LOG: "LOG";
+    readonly UPDATE_IN_DATABASE: "UPDATE_IN_DATABASE";
+};
+/**
+ * @public
+ */
+export type UpdateBehavior = (typeof UpdateBehavior)[keyof typeof UpdateBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const CrawlerState: {
+    readonly READY: "READY";
+    readonly RUNNING: "RUNNING";
+    readonly STOPPING: "STOPPING";
+};
+/**
+ * @public
+ */
+export type CrawlerState = (typeof CrawlerState)[keyof typeof CrawlerState];
+/**
+ * @public
+ * @enum
+ */
+export declare const JdbcMetadataEntry: {
+    readonly COMMENTS: "COMMENTS";
+    readonly RAWTYPES: "RAWTYPES";
+};
+/**
+ * @public
+ */
+export type JdbcMetadataEntry = (typeof JdbcMetadataEntry)[keyof typeof JdbcMetadataEntry];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataQualityRuleResultStatus: {
+    readonly ERROR: "ERROR";
+    readonly FAIL: "FAIL";
+    readonly PASS: "PASS";
+};
+/**
+ * @public
+ */
+export type DataQualityRuleResultStatus = (typeof DataQualityRuleResultStatus)[keyof typeof DataQualityRuleResultStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkerType: {
+    readonly G_025X: "G.025X";
+    readonly G_1X: "G.1X";
+    readonly G_2X: "G.2X";
+    readonly G_4X: "G.4X";
+    readonly G_8X: "G.8X";
+    readonly Standard: "Standard";
+    readonly Z_2X: "Z.2X";
+};
+/**
+ * @public
+ */
+export type WorkerType = (typeof WorkerType)[keyof typeof WorkerType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StartingPosition: {
+    readonly EARLIEST: "earliest";
+    readonly LATEST: "latest";
+    readonly TIMESTAMP: "timestamp";
+    readonly TRIM_HORIZON: "trim_horizon";
+};
+/**
+ * @public
+ */
+export type StartingPosition = (typeof StartingPosition)[keyof typeof StartingPosition];
+/**
+ * @public
+ * @enum
+ */
+export declare const JDBCConnectionType: {
+    readonly mysql: "mysql";
+    readonly oracle: "oracle";
+    readonly postgresql: "postgresql";
+    readonly redshift: "redshift";
+    readonly sqlserver: "sqlserver";
+};
+/**
+ * @public
+ */
+export type JDBCConnectionType = (typeof JDBCConnectionType)[keyof typeof JDBCConnectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParamType: {
+    readonly BOOL: "bool";
+    readonly COMPLEX: "complex";
+    readonly FLOAT: "float";
+    readonly INT: "int";
+    readonly LIST: "list";
+    readonly NULL: "null";
+    readonly STR: "str";
+};
+/**
+ * @public
+ */
+export type ParamType = (typeof ParamType)[keyof typeof ParamType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DdbExportType: {
+    readonly ddb: "ddb";
+    readonly s3: "s3";
+};
+/**
+ * @public
+ */
+export type DdbExportType = (typeof DdbExportType)[keyof typeof DdbExportType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DQTransformOutput: {
+    readonly EvaluationResults: "EvaluationResults";
+    readonly PrimaryInput: "PrimaryInput";
+};
+/**
+ * @public
+ */
+export type DQTransformOutput = (typeof DQTransformOutput)[keyof typeof DQTransformOutput];
+/**
+ * @public
+ * @enum
+ */
+export declare const DQStopJobOnFailureTiming: {
+    readonly AfterDataLoad: "AfterDataLoad";
+    readonly Immediate: "Immediate";
+};
+/**
+ * @public
+ */
+export type DQStopJobOnFailureTiming = (typeof DQStopJobOnFailureTiming)[keyof typeof DQStopJobOnFailureTiming];
+/**
+ * @public
+ * @enum
+ */
+export declare const FilterOperation: {
+    readonly EQ: "EQ";
+    readonly GT: "GT";
+    readonly GTE: "GTE";
+    readonly ISNULL: "ISNULL";
+    readonly LT: "LT";
+    readonly LTE: "LTE";
+    readonly REGEX: "REGEX";
+};
+/**
+ * @public
+ */
+export type FilterOperation = (typeof FilterOperation)[keyof typeof FilterOperation];
+/**
+ * @public
+ * @enum
+ */
+export declare const FilterValueType: {
+    readonly COLUMNEXTRACTED: "COLUMNEXTRACTED";
+    readonly CONSTANT: "CONSTANT";
+};
+/**
+ * @public
+ */
+export type FilterValueType = (typeof FilterValueType)[keyof typeof FilterValueType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FilterLogicalOperator: {
+    readonly AND: "AND";
+    readonly OR: "OR";
+};
+/**
+ * @public
+ */
+export type FilterLogicalOperator = (typeof FilterLogicalOperator)[keyof typeof FilterLogicalOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdateCatalogBehavior: {
+    readonly LOG: "LOG";
+    readonly UPDATE_IN_DATABASE: "UPDATE_IN_DATABASE";
+};
+/**
+ * @public
+ */
+export type UpdateCatalogBehavior = (typeof UpdateCatalogBehavior)[keyof typeof UpdateCatalogBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const JDBCDataType: {
+    readonly ARRAY: "ARRAY";
+    readonly BIGINT: "BIGINT";
+    readonly BINARY: "BINARY";
+    readonly BIT: "BIT";
+    readonly BLOB: "BLOB";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly CHAR: "CHAR";
+    readonly CLOB: "CLOB";
+    readonly DATALINK: "DATALINK";
+    readonly DATE: "DATE";
+    readonly DECIMAL: "DECIMAL";
+    readonly DISTINCT: "DISTINCT";
+    readonly DOUBLE: "DOUBLE";
+    readonly FLOAT: "FLOAT";
+    readonly INTEGER: "INTEGER";
+    readonly JAVA_OBJECT: "JAVA_OBJECT";
+    readonly LONGNVARCHAR: "LONGNVARCHAR";
+    readonly LONGVARBINARY: "LONGVARBINARY";
+    readonly LONGVARCHAR: "LONGVARCHAR";
+    readonly NCHAR: "NCHAR";
+    readonly NCLOB: "NCLOB";
+    readonly NULL: "NULL";
+    readonly NUMERIC: "NUMERIC";
+    readonly NVARCHAR: "NVARCHAR";
+    readonly OTHER: "OTHER";
+    readonly REAL: "REAL";
+    readonly REF: "REF";
+    readonly REF_CURSOR: "REF_CURSOR";
+    readonly ROWID: "ROWID";
+    readonly SMALLINT: "SMALLINT";
+    readonly SQLXML: "SQLXML";
+    readonly STRUCT: "STRUCT";
+    readonly TIME: "TIME";
+    readonly TIMESTAMP: "TIMESTAMP";
+    readonly TIMESTAMP_WITH_TIMEZONE: "TIMESTAMP_WITH_TIMEZONE";
+    readonly TIME_WITH_TIMEZONE: "TIME_WITH_TIMEZONE";
+    readonly TINYINT: "TINYINT";
+    readonly VARBINARY: "VARBINARY";
+    readonly VARCHAR: "VARCHAR";
+};
+/**
+ * @public
+ */
+export type JDBCDataType = (typeof JDBCDataType)[keyof typeof JDBCDataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const GlueRecordType: {
+    readonly BIGDECIMAL: "BIGDECIMAL";
+    readonly BYTE: "BYTE";
+    readonly DATE: "DATE";
+    readonly DOUBLE: "DOUBLE";
+    readonly FLOAT: "FLOAT";
+    readonly INT: "INT";
+    readonly LONG: "LONG";
+    readonly SHORT: "SHORT";
+    readonly STRING: "STRING";
+    readonly TIMESTAMP: "TIMESTAMP";
+};
+/**
+ * @public
+ */
+export type GlueRecordType = (typeof GlueRecordType)[keyof typeof GlueRecordType];
+/**
+ * @public
+ * @enum
+ */
+export declare const JoinType: {
+    readonly EQUIJOIN: "equijoin";
+    readonly LEFT: "left";
+    readonly LEFT_ANTI: "leftanti";
+    readonly LEFT_SEMI: "leftsemi";
+    readonly OUTER: "outer";
+    readonly RIGHT: "right";
+};
+/**
+ * @public
+ */
+export type JoinType = (typeof JoinType)[keyof typeof JoinType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PiiType: {
+    readonly ColumnAudit: "ColumnAudit";
+    readonly ColumnHashing: "ColumnHashing";
+    readonly ColumnMasking: "ColumnMasking";
+    readonly RowAudit: "RowAudit";
+    readonly RowHashing: "RowHashing";
+    readonly RowMasking: "RowMasking";
+    readonly RowPartialMasking: "RowPartialMasking";
+};
+/**
+ * @public
+ */
+export type PiiType = (typeof PiiType)[keyof typeof PiiType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CompressionType: {
+    readonly BZIP2: "bzip2";
+    readonly GZIP: "gzip";
+};
+/**
+ * @public
+ */
+export type CompressionType = (typeof CompressionType)[keyof typeof CompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const QuoteChar: {
+    readonly DISABLED: "disabled";
+    readonly QUILLEMET: "quillemet";
+    readonly QUOTE: "quote";
+    readonly SINGLE_QUOTE: "single_quote";
+};
+/**
+ * @public
+ */
+export type QuoteChar = (typeof QuoteChar)[keyof typeof QuoteChar];
+/**
+ * @public
+ * @enum
+ */
+export declare const Separator: {
+    readonly COMMA: "comma";
+    readonly CTRLA: "ctrla";
+    readonly PIPE: "pipe";
+    readonly SEMICOLON: "semicolon";
+    readonly TAB: "tab";
+};
+/**
+ * @public
+ */
+export type Separator = (typeof Separator)[keyof typeof Separator];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeltaTargetCompressionType: {
+    readonly SNAPPY: "snappy";
+    readonly UNCOMPRESSED: "uncompressed";
+};
+/**
+ * @public
+ */
+export type DeltaTargetCompressionType = (typeof DeltaTargetCompressionType)[keyof typeof DeltaTargetCompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TargetFormat: {
+    readonly AVRO: "avro";
+    readonly CSV: "csv";
+    readonly DELTA: "delta";
+    readonly HUDI: "hudi";
+    readonly HYPER: "hyper";
+    readonly ICEBERG: "iceberg";
+    readonly JSON: "json";
+    readonly ORC: "orc";
+    readonly PARQUET: "parquet";
+    readonly XML: "xml";
+};
+/**
+ * @public
+ */
+export type TargetFormat = (typeof TargetFormat)[keyof typeof TargetFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParquetCompressionType: {
+    readonly BROTLI: "brotli";
+    readonly GZIP: "gzip";
+    readonly LZ4: "lz4";
+    readonly LZO: "lzo";
+    readonly NONE: "none";
+    readonly SNAPPY: "snappy";
+    readonly UNCOMPRESSED: "uncompressed";
+};
+/**
+ * @public
+ */
+export type ParquetCompressionType = (typeof ParquetCompressionType)[keyof typeof ParquetCompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const HudiTargetCompressionType: {
+    readonly GZIP: "gzip";
+    readonly LZO: "lzo";
+    readonly SNAPPY: "snappy";
+    readonly UNCOMPRESSED: "uncompressed";
+};
+/**
+ * @public
+ */
+export type HudiTargetCompressionType = (typeof HudiTargetCompressionType)[keyof typeof HudiTargetCompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const HyperTargetCompressionType: {
+    readonly UNCOMPRESSED: "uncompressed";
+};
+/**
+ * @public
+ */
+export type HyperTargetCompressionType = (typeof HyperTargetCompressionType)[keyof typeof HyperTargetCompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IcebergTargetCompressionType: {
+    readonly GZIP: "gzip";
+    readonly LZO: "lzo";
+    readonly SNAPPY: "snappy";
+    readonly UNCOMPRESSED: "uncompressed";
+};
+/**
+ * @public
+ */
+export type IcebergTargetCompressionType = (typeof IcebergTargetCompressionType)[keyof typeof IcebergTargetCompressionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const UnionType: {
+    readonly ALL: "ALL";
+    readonly DISTINCT: "DISTINCT";
+};
+/**
+ * @public
+ */
+export type UnionType = (typeof UnionType)[keyof typeof UnionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionClass: {
+    readonly FLEX: "FLEX";
+    readonly STANDARD: "STANDARD";
+};
+/**
+ * @public
+ */
+export type ExecutionClass = (typeof ExecutionClass)[keyof typeof ExecutionClass];
+/**
+ * @public
+ * @enum
+ */
+export declare const JobMode: {
+    readonly NOTEBOOK: "NOTEBOOK";
+    readonly SCRIPT: "SCRIPT";
+    readonly VISUAL: "VISUAL";
+};
+/**
+ * @public
+ */
+export type JobMode = (typeof JobMode)[keyof typeof JobMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const SourceControlAuthStrategy: {
+    readonly AWS_SECRETS_MANAGER: "AWS_SECRETS_MANAGER";
+    readonly PERSONAL_ACCESS_TOKEN: "PERSONAL_ACCESS_TOKEN";
+};
+/**
+ * @public
+ */
+export type SourceControlAuthStrategy = (typeof SourceControlAuthStrategy)[keyof typeof SourceControlAuthStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const SourceControlProvider: {
+    readonly AWS_CODE_COMMIT: "AWS_CODE_COMMIT";
+    readonly BITBUCKET: "BITBUCKET";
+    readonly GITHUB: "GITHUB";
+    readonly GITLAB: "GITLAB";
+};
+/**
+ * @public
+ */
+export type SourceControlProvider = (typeof SourceControlProvider)[keyof typeof SourceControlProvider];
+/**
+ * @public
+ * @enum
+ */
+export declare const FederationSourceErrorCode: {
+    readonly AccessDeniedException: "AccessDeniedException";
+    readonly EntityNotFoundException: "EntityNotFoundException";
+    readonly InternalServiceException: "InternalServiceException";
+    readonly InvalidCredentialsException: "InvalidCredentialsException";
+    readonly InvalidInputException: "InvalidInputException";
+    readonly InvalidResponseException: "InvalidResponseException";
+    readonly OperationNotSupportedException: "OperationNotSupportedException";
+    readonly OperationTimeoutException: "OperationTimeoutException";
+    readonly PartialFailureException: "PartialFailureException";
+    readonly ThrottlingException: "ThrottlingException";
+};
+/**
+ * @public
+ */
+export type FederationSourceErrorCode = (typeof FederationSourceErrorCode)[keyof typeof FederationSourceErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const TableOptimizerType: {
+    readonly COMPACTION: "compaction";
+    readonly ORPHAN_FILE_DELETION: "orphan_file_deletion";
+    readonly RETENTION: "retention";
+};
+/**
+ * @public
+ */
+export type TableOptimizerType = (typeof TableOptimizerType)[keyof typeof TableOptimizerType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CompactionStrategy: {
+    readonly BINPACK: "binpack";
+    readonly SORT: "sort";
+    readonly ZORDER: "z-order";
+};
+/**
+ * @public
+ */
+export type CompactionStrategy = (typeof CompactionStrategy)[keyof typeof CompactionStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConfigurationSource: {
+    readonly CATALOG: "catalog";
+    readonly TABLE: "table";
+};
+/**
+ * @public
+ */
+export type ConfigurationSource = (typeof ConfigurationSource)[keyof typeof ConfigurationSource];
+/**
+ * @public
+ * @enum
+ */
+export declare const TableOptimizerEventType: {
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly IN_PROGRESS: "in_progress";
+    readonly STARTING: "starting";
+};
+/**
+ * @public
+ */
+export type TableOptimizerEventType = (typeof TableOptimizerEventType)[keyof typeof TableOptimizerEventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CrawlState: {
+    readonly CANCELLED: "CANCELLED";
+    readonly CANCELLING: "CANCELLING";
+    readonly ERROR: "ERROR";
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type CrawlState = (typeof CrawlState)[keyof typeof CrawlState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LogicalOperator: {
+    readonly EQUALS: "EQUALS";
+};
+/**
+ * @public
+ */
+export type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const JobRunState: {
+    readonly ERROR: "ERROR";
+    readonly EXPIRED: "EXPIRED";
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly STARTING: "STARTING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+    readonly SUCCEEDED: "SUCCEEDED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly WAITING: "WAITING";
+};
+/**
+ * @public
+ */
+export type JobRunState = (typeof JobRunState)[keyof typeof JobRunState];
+/**
+ * @public
+ * @enum
+ */
+export declare const Logical: {
+    readonly AND: "AND";
+    readonly ANY: "ANY";
+};
+/**
+ * @public
+ */
+export type Logical = (typeof Logical)[keyof typeof Logical];
+/**
+ * @public
+ * @enum
+ */
+export declare const TriggerState: {
+    readonly ACTIVATED: "ACTIVATED";
+    readonly ACTIVATING: "ACTIVATING";
+    readonly CREATED: "CREATED";
+    readonly CREATING: "CREATING";
+    readonly DEACTIVATED: "DEACTIVATED";
+    readonly DEACTIVATING: "DEACTIVATING";
+    readonly DELETING: "DELETING";
+    readonly UPDATING: "UPDATING";
+};
+/**
+ * @public
+ */
+export type TriggerState = (typeof TriggerState)[keyof typeof TriggerState];
+/**
+ * @public
+ * @enum
+ */
+export declare const TriggerType: {
+    readonly CONDITIONAL: "CONDITIONAL";
+    readonly EVENT: "EVENT";
+    readonly ON_DEMAND: "ON_DEMAND";
+    readonly SCHEDULED: "SCHEDULED";
+};
+/**
+ * @public
+ */
+export type TriggerType = (typeof TriggerType)[keyof typeof TriggerType];
+/**
+ * @public
+ * @enum
+ */
+export declare const NodeType: {
+    readonly CRAWLER: "CRAWLER";
+    readonly JOB: "JOB";
+    readonly TRIGGER: "TRIGGER";
+};
+/**
+ * @public
+ */
+export type NodeType = (typeof NodeType)[keyof typeof NodeType];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkflowRunStatus: {
+    readonly COMPLETED: "COMPLETED";
+    readonly ERROR: "ERROR";
+    readonly RUNNING: "RUNNING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+};
+/**
+ * @public
+ */
+export type WorkflowRunStatus = (typeof WorkflowRunStatus)[keyof typeof WorkflowRunStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const TaskStatusType: {
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly STARTING: "STARTING";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+    readonly SUCCEEDED: "SUCCEEDED";
+    readonly TIMEOUT: "TIMEOUT";
+};
+/**
+ * @public
+ */
+export type TaskStatusType = (typeof TaskStatusType)[keyof typeof TaskStatusType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataFormat: {
+    readonly AVRO: "AVRO";
+    readonly JSON: "JSON";
+    readonly PROTOBUF: "PROTOBUF";
+};
+/**
+ * @public
+ */
+export type DataFormat = (typeof DataFormat)[keyof typeof DataFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const Permission: {
+    readonly ALL: "ALL";
+    readonly ALTER: "ALTER";
+    readonly CREATE_DATABASE: "CREATE_DATABASE";
+    readonly CREATE_TABLE: "CREATE_TABLE";
+    readonly DATA_LOCATION_ACCESS: "DATA_LOCATION_ACCESS";
+    readonly DELETE: "DELETE";
+    readonly DROP: "DROP";
+    readonly INSERT: "INSERT";
+    readonly SELECT: "SELECT";
+};
+/**
+ * @public
+ */
+export type Permission = (typeof Permission)[keyof typeof Permission];
+/**
+ * @public
+ * @enum
+ */
+export declare const CsvHeaderOption: {
+    readonly ABSENT: "ABSENT";
+    readonly PRESENT: "PRESENT";
+    readonly UNKNOWN: "UNKNOWN";
+};
+/**
+ * @public
+ */
+export type CsvHeaderOption = (typeof CsvHeaderOption)[keyof typeof CsvHeaderOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const CsvSerdeOption: {
+    readonly LazySimpleSerDe: "LazySimpleSerDe";
+    readonly None: "None";
+    readonly OpenCSVSerDe: "OpenCSVSerDe";
+};
+/**
+ * @public
+ */
+export type CsvSerdeOption = (typeof CsvSerdeOption)[keyof typeof CsvSerdeOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionPropertyKey: {
+    readonly CLUSTER_IDENTIFIER: "CLUSTER_IDENTIFIER";
+    readonly CONFIG_FILES: "CONFIG_FILES";
+    readonly CONNECTION_URL: "CONNECTION_URL";
+    readonly CONNECTOR_CLASS_NAME: "CONNECTOR_CLASS_NAME";
+    readonly CONNECTOR_TYPE: "CONNECTOR_TYPE";
+    readonly CONNECTOR_URL: "CONNECTOR_URL";
+    readonly CUSTOM_JDBC_CERT: "CUSTOM_JDBC_CERT";
+    readonly CUSTOM_JDBC_CERT_STRING: "CUSTOM_JDBC_CERT_STRING";
+    readonly DATABASE: "DATABASE";
+    readonly ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD: "ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD";
+    readonly ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD: "ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD";
+    readonly ENCRYPTED_KAFKA_SASL_PLAIN_PASSWORD: "ENCRYPTED_KAFKA_SASL_PLAIN_PASSWORD";
+    readonly ENCRYPTED_KAFKA_SASL_SCRAM_PASSWORD: "ENCRYPTED_KAFKA_SASL_SCRAM_PASSWORD";
+    readonly ENCRYPTED_PASSWORD: "ENCRYPTED_PASSWORD";
+    readonly ENDPOINT: "ENDPOINT";
+    readonly ENDPOINT_TYPE: "ENDPOINT_TYPE";
+    readonly HOST: "HOST";
+    readonly INSTANCE_ID: "INSTANCE_ID";
+    readonly JDBC_CONNECTION_URL: "JDBC_CONNECTION_URL";
+    readonly JDBC_DRIVER_CLASS_NAME: "JDBC_DRIVER_CLASS_NAME";
+    readonly JDBC_DRIVER_JAR_URI: "JDBC_DRIVER_JAR_URI";
+    readonly JDBC_ENFORCE_SSL: "JDBC_ENFORCE_SSL";
+    readonly JDBC_ENGINE: "JDBC_ENGINE";
+    readonly JDBC_ENGINE_VERSION: "JDBC_ENGINE_VERSION";
+    readonly KAFKA_BOOTSTRAP_SERVERS: "KAFKA_BOOTSTRAP_SERVERS";
+    readonly KAFKA_CLIENT_KEYSTORE: "KAFKA_CLIENT_KEYSTORE";
+    readonly KAFKA_CLIENT_KEYSTORE_PASSWORD: "KAFKA_CLIENT_KEYSTORE_PASSWORD";
+    readonly KAFKA_CLIENT_KEY_PASSWORD: "KAFKA_CLIENT_KEY_PASSWORD";
+    readonly KAFKA_CUSTOM_CERT: "KAFKA_CUSTOM_CERT";
+    readonly KAFKA_SASL_GSSAPI_KEYTAB: "KAFKA_SASL_GSSAPI_KEYTAB";
+    readonly KAFKA_SASL_GSSAPI_KRB5_CONF: "KAFKA_SASL_GSSAPI_KRB5_CONF";
+    readonly KAFKA_SASL_GSSAPI_PRINCIPAL: "KAFKA_SASL_GSSAPI_PRINCIPAL";
+    readonly KAFKA_SASL_GSSAPI_SERVICE: "KAFKA_SASL_GSSAPI_SERVICE";
+    readonly KAFKA_SASL_MECHANISM: "KAFKA_SASL_MECHANISM";
+    readonly KAFKA_SASL_PLAIN_PASSWORD: "KAFKA_SASL_PLAIN_PASSWORD";
+    readonly KAFKA_SASL_PLAIN_USERNAME: "KAFKA_SASL_PLAIN_USERNAME";
+    readonly KAFKA_SASL_SCRAM_PASSWORD: "KAFKA_SASL_SCRAM_PASSWORD";
+    readonly KAFKA_SASL_SCRAM_SECRETS_ARN: "KAFKA_SASL_SCRAM_SECRETS_ARN";
+    readonly KAFKA_SASL_SCRAM_USERNAME: "KAFKA_SASL_SCRAM_USERNAME";
+    readonly KAFKA_SKIP_CUSTOM_CERT_VALIDATION: "KAFKA_SKIP_CUSTOM_CERT_VALIDATION";
+    readonly KAFKA_SSL_ENABLED: "KAFKA_SSL_ENABLED";
+    readonly PASSWORD: "PASSWORD";
+    readonly PORT: "PORT";
+    readonly REGION: "REGION";
+    readonly ROLE_ARN: "ROLE_ARN";
+    readonly SECRET_ID: "SECRET_ID";
+    readonly SKIP_CUSTOM_JDBC_CERT_VALIDATION: "SKIP_CUSTOM_JDBC_CERT_VALIDATION";
+    readonly USER_NAME: "USERNAME";
+    readonly WORKGROUP_NAME: "WORKGROUP_NAME";
+};
+/**
+ * @public
+ */
+export type ConnectionPropertyKey = (typeof ConnectionPropertyKey)[keyof typeof ConnectionPropertyKey];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionType: {
+    readonly ADOBEANALYTICS: "ADOBEANALYTICS";
+    readonly ASANA: "ASANA";
+    readonly AZURECOSMOS: "AZURECOSMOS";
+    readonly AZURESQL: "AZURESQL";
+    readonly BIGQUERY: "BIGQUERY";
+    readonly BLACKBAUD: "BLACKBAUD";
+    readonly BLACKBAUDRAISEREDGENXT: "BLACKBAUDRAISEREDGENXT";
+    readonly CIRCLECI: "CIRCLECI";
+    readonly CLOUDERAHIVE: "CLOUDERAHIVE";
+    readonly CLOUDERAIMPALA: "CLOUDERAIMPALA";
+    readonly CLOUDWATCH: "CLOUDWATCH";
+    readonly CLOUDWATCHMETRICS: "CLOUDWATCHMETRICS";
+    readonly CMDB: "CMDB";
+    readonly CUSTOM: "CUSTOM";
+    readonly DATADOG: "DATADOG";
+    readonly DATALAKEGEN2: "DATALAKEGEN2";
+    readonly DB2: "DB2";
+    readonly DB2AS400: "DB2AS400";
+    readonly DOCUMENTDB: "DOCUMENTDB";
+    readonly DOCUSIGNMONITOR: "DOCUSIGNMONITOR";
+    readonly DOMO: "DOMO";
+    readonly DYNAMODB: "DYNAMODB";
+    readonly DYNATRACE: "DYNATRACE";
+    readonly FACEBOOKADS: "FACEBOOKADS";
+    readonly FACEBOOKPAGEINSIGHTS: "FACEBOOKPAGEINSIGHTS";
+    readonly FRESHDESK: "FRESHDESK";
+    readonly FRESHSALES: "FRESHSALES";
+    readonly GITLAB: "GITLAB";
+    readonly GOOGLEADS: "GOOGLEADS";
+    readonly GOOGLEANALYTICS4: "GOOGLEANALYTICS4";
+    readonly GOOGLECLOUDSTORAGE: "GOOGLECLOUDSTORAGE";
+    readonly GOOGLESEARCHCONSOLE: "GOOGLESEARCHCONSOLE";
+    readonly GOOGLESHEETS: "GOOGLESHEETS";
+    readonly HBASE: "HBASE";
+    readonly HUBSPOT: "HUBSPOT";
+    readonly INSTAGRAMADS: "INSTAGRAMADS";
+    readonly INTERCOM: "INTERCOM";
+    readonly JDBC: "JDBC";
+    readonly JIRACLOUD: "JIRACLOUD";
+    readonly KAFKA: "KAFKA";
+    readonly KUSTOMER: "KUSTOMER";
+    readonly LINKEDIN: "LINKEDIN";
+    readonly MAILCHIMP: "MAILCHIMP";
+    readonly MARKETO: "MARKETO";
+    readonly MARKETPLACE: "MARKETPLACE";
+    readonly MICROSOFTDYNAMIC365FINANCEANDOPS: "MICROSOFTDYNAMIC365FINANCEANDOPS";
+    readonly MICROSOFTDYNAMICS365CRM: "MICROSOFTDYNAMICS365CRM";
+    readonly MICROSOFTTEAMS: "MICROSOFTTEAMS";
+    readonly MIXPANEL: "MIXPANEL";
+    readonly MONDAY: "MONDAY";
+    readonly MONGODB: "MONGODB";
+    readonly MYSQL: "MYSQL";
+    readonly NETSUITEERP: "NETSUITEERP";
+    readonly NETWORK: "NETWORK";
+    readonly OKTA: "OKTA";
+    readonly OPENSEARCH: "OPENSEARCH";
+    readonly ORACLE: "ORACLE";
+    readonly PAYPAL: "PAYPAL";
+    readonly PENDO: "PENDO";
+    readonly PIPEDIVE: "PIPEDIVE";
+    readonly PIPEDRIVE: "PIPEDRIVE";
+    readonly POSTGRESQL: "POSTGRESQL";
+    readonly PRODUCTBOARD: "PRODUCTBOARD";
+    readonly QUICKBOOKS: "QUICKBOOKS";
+    readonly SALESFORCE: "SALESFORCE";
+    readonly SALESFORCECOMMERCECLOUD: "SALESFORCECOMMERCECLOUD";
+    readonly SALESFORCEMARKETINGCLOUD: "SALESFORCEMARKETINGCLOUD";
+    readonly SALESFORCEPARDOT: "SALESFORCEPARDOT";
+    readonly SAPCONCUR: "SAPCONCUR";
+    readonly SAPHANA: "SAPHANA";
+    readonly SAPODATA: "SAPODATA";
+    readonly SENDGRID: "SENDGRID";
+    readonly SERVICENOW: "SERVICENOW";
+    readonly SFTP: "SFTP";
+    readonly SLACK: "SLACK";
+    readonly SMARTSHEET: "SMARTSHEET";
+    readonly SNAPCHATADS: "SNAPCHATADS";
+    readonly SQLSERVER: "SQLSERVER";
+    readonly STRIPE: "STRIPE";
+    readonly SYNAPSE: "SYNAPSE";
+    readonly TERADATA: "TERADATA";
+    readonly TERADATANOS: "TERADATANOS";
+    readonly TIMESTREAM: "TIMESTREAM";
+    readonly TPCDS: "TPCDS";
+    readonly TWILIO: "TWILIO";
+    readonly VERTICA: "VERTICA";
+    readonly VIEW_VALIDATION_ATHENA: "VIEW_VALIDATION_ATHENA";
+    readonly VIEW_VALIDATION_REDSHIFT: "VIEW_VALIDATION_REDSHIFT";
+    readonly WOOCOMMERCE: "WOOCOMMERCE";
+    readonly ZENDESK: "ZENDESK";
+    readonly ZOHOCRM: "ZOHOCRM";
+    readonly ZOOM: "ZOOM";
+};
+/**
+ * @public
+ */
+export type ConnectionType = (typeof ConnectionType)[keyof typeof ConnectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ComputeEnvironment: {
+    readonly ATHENA: "ATHENA";
+    readonly PYTHON: "PYTHON";
+    readonly SPARK: "SPARK";
+};
+/**
+ * @public
+ */
+export type ComputeEnvironment = (typeof ComputeEnvironment)[keyof typeof ComputeEnvironment];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionStatus: {
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly READY: "READY";
+};
+/**
+ * @public
+ */
+export type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const IntegrationStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+    readonly MODIFYING: "MODIFYING";
+    readonly NEEDS_ATTENTION: "NEEDS_ATTENTION";
+    readonly SYNCING: "SYNCING";
+};
+/**
+ * @public
+ */
+export type IntegrationStatus = (typeof IntegrationStatus)[keyof typeof IntegrationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const UnnestSpec: {
+    readonly FULL: "FULL";
+    readonly NOUNNEST: "NOUNNEST";
+    readonly TOPLEVEL: "TOPLEVEL";
+};
+/**
+ * @public
+ */
+export type UnnestSpec = (typeof UnnestSpec)[keyof typeof UnnestSpec];
+/**
+ * @public
+ * @enum
+ */
+export declare const TransformType: {
+    readonly FIND_MATCHES: "FIND_MATCHES";
+};
+/**
+ * @public
+ */
+export type TransformType = (typeof TransformType)[keyof typeof TransformType];
+/**
+ * @public
+ * @enum
+ */
+export declare const MLUserDataEncryptionModeString: {
+    readonly DISABLED: "DISABLED";
+    readonly SSEKMS: "SSE-KMS";
+};
+/**
+ * @public
+ */
+export type MLUserDataEncryptionModeString = (typeof MLUserDataEncryptionModeString)[keyof typeof MLUserDataEncryptionModeString];
+/**
+ * @public
+ * @enum
+ */
+export declare const Compatibility: {
+    readonly BACKWARD: "BACKWARD";
+    readonly BACKWARD_ALL: "BACKWARD_ALL";
+    readonly DISABLED: "DISABLED";
+    readonly FORWARD: "FORWARD";
+    readonly FORWARD_ALL: "FORWARD_ALL";
+    readonly FULL: "FULL";
+    readonly FULL_ALL: "FULL_ALL";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type Compatibility = (typeof Compatibility)[keyof typeof Compatibility];
+/**
+ * @public
+ * @enum
+ */
+export declare const SchemaStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly DELETING: "DELETING";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type SchemaStatus = (typeof SchemaStatus)[keyof typeof SchemaStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const SchemaVersionStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly DELETING: "DELETING";
+    readonly FAILURE: "FAILURE";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type SchemaVersionStatus = (typeof SchemaVersionStatus)[keyof typeof SchemaVersionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const Language: {
+    readonly PYTHON: "PYTHON";
+    readonly SCALA: "SCALA";
+};
+/**
+ * @public
+ */
+export type Language = (typeof Language)[keyof typeof Language];
+/**
+ * @public
+ * @enum
+ */
+export declare const CloudWatchEncryptionMode: {
+    readonly DISABLED: "DISABLED";
+    readonly SSEKMS: "SSE-KMS";
+};
+/**
+ * @public
+ */
+export type CloudWatchEncryptionMode = (typeof CloudWatchEncryptionMode)[keyof typeof CloudWatchEncryptionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataQualityEncryptionMode: {
+    readonly DISABLED: "DISABLED";
+    readonly SSEKMS: "SSE-KMS";
+};
+/**
+ * @public
+ */
+export type DataQualityEncryptionMode = (typeof DataQualityEncryptionMode)[keyof typeof DataQualityEncryptionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const JobBookmarksEncryptionMode: {
+    readonly CSEKMS: "CSE-KMS";
+    readonly DISABLED: "DISABLED";
+};
+/**
+ * @public
+ */
+export type JobBookmarksEncryptionMode = (typeof JobBookmarksEncryptionMode)[keyof typeof JobBookmarksEncryptionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const S3EncryptionMode: {
+    readonly DISABLED: "DISABLED";
+    readonly SSEKMS: "SSE-KMS";
+    readonly SSES3: "SSE-S3";
+};
+/**
+ * @public
+ */
+export type S3EncryptionMode = (typeof S3EncryptionMode)[keyof typeof S3EncryptionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const SessionStatus: {
+    readonly FAILED: "FAILED";
+    readonly PROVISIONING: "PROVISIONING";
+    readonly READY: "READY";
+    readonly STOPPED: "STOPPED";
+    readonly STOPPING: "STOPPING";
+    readonly TIMEOUT: "TIMEOUT";
+};
+/**
+ * @public
+ */
+export type SessionStatus = (typeof SessionStatus)[keyof typeof SessionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const IcebergStructTypeEnum: {
+    readonly STRUCT: "struct";
+};
+/**
+ * @public
+ */
+export type IcebergStructTypeEnum = (typeof IcebergStructTypeEnum)[keyof typeof IcebergStructTypeEnum];
+/**
+ * @public
+ * @enum
+ */
+export declare const IcebergSortDirection: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+/**
+ * @public
+ */
+export type IcebergSortDirection = (typeof IcebergSortDirection)[keyof typeof IcebergSortDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const IcebergNullOrder: {
+    readonly NULLS_FIRST: "nulls-first";
+    readonly NULLS_LAST: "nulls-last";
+};
+/**
+ * @public
+ */
+export type IcebergNullOrder = (typeof IcebergNullOrder)[keyof typeof IcebergNullOrder];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetadataOperation: {
+    readonly CREATE: "CREATE";
+};
+/**
+ * @public
+ */
+export type MetadataOperation = (typeof MetadataOperation)[keyof typeof MetadataOperation];
+/**
+ * @public
+ * @enum
+ */
+export declare const ViewDialect: {
+    readonly ATHENA: "ATHENA";
+    readonly REDSHIFT: "REDSHIFT";
+    readonly SPARK: "SPARK";
+};
+/**
+ * @public
+ */
+export type ViewDialect = (typeof ViewDialect)[keyof typeof ViewDialect];
+/**
+ * @public
+ * @enum
+ */
+export declare const PrincipalType: {
+    readonly GROUP: "GROUP";
+    readonly ROLE: "ROLE";
+    readonly USER: "USER";
+};
+/**
+ * @public
+ */
+export type PrincipalType = (typeof PrincipalType)[keyof typeof PrincipalType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceType: {
+    readonly ARCHIVE: "ARCHIVE";
+    readonly FILE: "FILE";
+    readonly JAR: "JAR";
+};
+/**
+ * @public
+ */
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RegistryStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly DELETING: "DELETING";
+};
+/**
+ * @public
+ */
+export type RegistryStatus = (typeof RegistryStatus)[keyof typeof RegistryStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const FieldDataType: {
+    readonly ARRAY: "ARRAY";
+    readonly BIGINT: "BIGINT";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly BYTE: "BYTE";
+    readonly DATE: "DATE";
+    readonly DECIMAL: "DECIMAL";
+    readonly DOUBLE: "DOUBLE";
+    readonly FLOAT: "FLOAT";
+    readonly INT: "INT";
+    readonly LONG: "LONG";
+    readonly MAP: "MAP";
+    readonly SHORT: "SHORT";
+    readonly SMALLINT: "SMALLINT";
+    readonly STRING: "STRING";
+    readonly STRUCT: "STRUCT";
+    readonly TIMESTAMP: "TIMESTAMP";
+};
+/**
+ * @public
+ */
+export type FieldDataType = (typeof FieldDataType)[keyof typeof FieldDataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FieldFilterOperator: {
+    readonly BETWEEN: "BETWEEN";
+    readonly CONTAINS: "CONTAINS";
+    readonly EQUAL_TO: "EQUAL_TO";
+    readonly GREATER_THAN: "GREATER_THAN";
+    readonly GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO";
+    readonly LESS_THAN: "LESS_THAN";
+    readonly LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO";
+    readonly NOT_EQUAL_TO: "NOT_EQUAL_TO";
+    readonly ORDER_BY: "ORDER_BY";
+};
+/**
+ * @public
+ */
+export type FieldFilterOperator = (typeof FieldFilterOperator)[keyof typeof FieldFilterOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const BlueprintRunState: {
+    readonly FAILED: "FAILED";
+    readonly ROLLING_BACK: "ROLLING_BACK";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type BlueprintRunState = (typeof BlueprintRunState)[keyof typeof BlueprintRunState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ColumnStatisticsType: {
+    readonly BINARY: "BINARY";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly DATE: "DATE";
+    readonly DECIMAL: "DECIMAL";
+    readonly DOUBLE: "DOUBLE";
+    readonly LONG: "LONG";
+    readonly STRING: "STRING";
+};
+/**
+ * @public
+ */
+export type ColumnStatisticsType = (typeof ColumnStatisticsType)[keyof typeof ColumnStatisticsType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ComputationType: {
+    readonly FULL: "FULL";
+    readonly INCREMENTAL: "INCREMENTAL";
+};
+/**
+ * @public
+ */
+export type ComputationType = (typeof ComputationType)[keyof typeof ComputationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ColumnStatisticsState: {
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly STARTING: "STARTING";
+    readonly STOPPED: "STOPPED";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type ColumnStatisticsState = (typeof ColumnStatisticsState)[keyof typeof ColumnStatisticsState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionStatus: {
+    readonly FAILED: "FAILED";
+    readonly STARTED: "STARTED";
+};
+/**
+ * @public
+ */
+export type ExecutionStatus = (typeof ExecutionStatus)[keyof typeof ExecutionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScheduleType: {
+    readonly AUTO: "AUTO";
+    readonly CRON: "CRON";
+};
+/**
+ * @public
+ */
+export type ScheduleType = (typeof ScheduleType)[keyof typeof ScheduleType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SettingSource: {
+    readonly CATALOG: "CATALOG";
+    readonly TABLE: "TABLE";
+};
+/**
+ * @public
+ */
+export type SettingSource = (typeof SettingSource)[keyof typeof SettingSource];
+/**
+ * @public
+ * @enum
+ */
+export declare const DatabaseAttributes: {
+    readonly NAME: "NAME";
+    readonly TARGET_DATABASE: "TARGET_DATABASE";
+};
+/**
+ * @public
+ */
+export type DatabaseAttributes = (typeof DatabaseAttributes)[keyof typeof DatabaseAttributes];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceShareType: {
+    readonly ALL: "ALL";
+    readonly FEDERATED: "FEDERATED";
+    readonly FOREIGN: "FOREIGN";
+};
+/**
+ * @public
+ */
+export type ResourceShareType = (typeof ResourceShareType)[keyof typeof ResourceShareType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CatalogEncryptionMode: {
+    readonly DISABLED: "DISABLED";
+    readonly SSEKMS: "SSE-KMS";
+    readonly SSEKMSWITHSERVICEROLE: "SSE-KMS-WITH-SERVICE-ROLE";
+};
+/**
+ * @public
+ */
+export type CatalogEncryptionMode = (typeof CatalogEncryptionMode)[keyof typeof CatalogEncryptionMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataQualityModelStatus: {
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type DataQualityModelStatus = (typeof DataQualityModelStatus)[keyof typeof DataQualityModelStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const DQCompositeRuleEvaluationMethod: {
+    readonly COLUMN: "COLUMN";
+    readonly ROW: "ROW";
+};
+/**
+ * @public
+ */
+export type DQCompositeRuleEvaluationMethod = (typeof DQCompositeRuleEvaluationMethod)[keyof typeof DQCompositeRuleEvaluationMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const TaskType: {
+    readonly EVALUATION: "EVALUATION";
+    readonly EXPORT_LABELS: "EXPORT_LABELS";
+    readonly FIND_MATCHES: "FIND_MATCHES";
+    readonly IMPORT_LABELS: "IMPORT_LABELS";
+    readonly LABELING_SET_GENERATION: "LABELING_SET_GENERATION";
+};
+/**
+ * @public
+ */
+export type TaskType = (typeof TaskType)[keyof typeof TaskType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TaskRunSortColumnType: {
+    readonly STARTED: "STARTED";
+    readonly STATUS: "STATUS";
+    readonly TASK_RUN_TYPE: "TASK_RUN_TYPE";
+};
+/**
+ * @public
+ */
+export type TaskRunSortColumnType = (typeof TaskRunSortColumnType)[keyof typeof TaskRunSortColumnType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SortDirectionType: {
+    readonly ASCENDING: "ASCENDING";
+    readonly DESCENDING: "DESCENDING";
+};
+/**
+ * @public
+ */
+export type SortDirectionType = (typeof SortDirectionType)[keyof typeof SortDirectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TransformStatusType: {
+    readonly DELETING: "DELETING";
+    readonly NOT_READY: "NOT_READY";
+    readonly READY: "READY";
+};
+/**
+ * @public
+ */
+export type TransformStatusType = (typeof TransformStatusType)[keyof typeof TransformStatusType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TransformSortColumnType: {
+    readonly CREATED: "CREATED";
+    readonly LAST_MODIFIED: "LAST_MODIFIED";
+    readonly NAME: "NAME";
+    readonly STATUS: "STATUS";
+    readonly TRANSFORM_TYPE: "TRANSFORM_TYPE";
+};
+/**
+ * @public
+ */
+export type TransformSortColumnType = (typeof TransformSortColumnType)[keyof typeof TransformSortColumnType];
+/**
+ * @public
+ * @enum
+ */
+export declare const BackfillErrorCode: {
+    readonly ENCRYPTED_PARTITION_ERROR: "ENCRYPTED_PARTITION_ERROR";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly INVALID_PARTITION_TYPE_DATA_ERROR: "INVALID_PARTITION_TYPE_DATA_ERROR";
+    readonly MISSING_PARTITION_VALUE_ERROR: "MISSING_PARTITION_VALUE_ERROR";
+    readonly UNSUPPORTED_PARTITION_CHARACTER_ERROR: "UNSUPPORTED_PARTITION_CHARACTER_ERROR";
+};
+/**
+ * @public
+ */
+export type BackfillErrorCode = (typeof BackfillErrorCode)[keyof typeof BackfillErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const PartitionIndexStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATING: "CREATING";
+    readonly DELETING: "DELETING";
+    readonly FAILED: "FAILED";
+};
+/**
+ * @public
+ */
+export type PartitionIndexStatus = (typeof PartitionIndexStatus)[keyof typeof PartitionIndexStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const SchemaDiffType: {
+    readonly SYNTAX_DIFF: "SYNTAX_DIFF";
+};
+/**
+ * @public
+ */
+export type SchemaDiffType = (typeof SchemaDiffType)[keyof typeof SchemaDiffType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatementState: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly CANCELLED: "CANCELLED";
+    readonly CANCELLING: "CANCELLING";
+    readonly ERROR: "ERROR";
+    readonly RUNNING: "RUNNING";
+    readonly WAITING: "WAITING";
+};
+/**
+ * @public
+ */
+export type StatementState = (typeof StatementState)[keyof typeof StatementState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceAction: {
+    readonly CREATE: "CREATE";
+    readonly UPDATE: "UPDATE";
+};
+/**
+ * @public
+ */
+export type ResourceAction = (typeof ResourceAction)[keyof typeof ResourceAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceState: {
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly QUEUED: "QUEUED";
+    readonly STOPPED: "STOPPED";
+    readonly SUCCESS: "SUCCESS";
+};
+/**
+ * @public
+ */
+export type ResourceState = (typeof ResourceState)[keyof typeof ResourceState];
+/**
+ * @public
+ * @enum
+ */
+export declare const TableAttributes: {
+    readonly NAME: "NAME";
+    readonly TABLE_TYPE: "TABLE_TYPE";
+};
+/**
+ * @public
+ */
+export type TableAttributes = (typeof TableAttributes)[keyof typeof TableAttributes];
+/**
+ * @public
+ * @enum
+ */
+export declare const PermissionType: {
+    readonly CELL_FILTER_PERMISSION: "CELL_FILTER_PERMISSION";
+    readonly COLUMN_PERMISSION: "COLUMN_PERMISSION";
+    readonly NESTED_CELL_PERMISSION: "NESTED_CELL_PERMISSION";
+    readonly NESTED_PERMISSION: "NESTED_PERMISSION";
+};
+/**
+ * @public
+ */
+export type PermissionType = (typeof PermissionType)[keyof typeof PermissionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FieldName: {
+    readonly CRAWL_ID: "CRAWL_ID";
+    readonly DPU_HOUR: "DPU_HOUR";
+    readonly END_TIME: "END_TIME";
+    readonly START_TIME: "START_TIME";
+    readonly STATE: "STATE";
+};
+/**
+ * @public
+ */
+export type FieldName = (typeof FieldName)[keyof typeof FieldName];
+/**
+ * @public
+ * @enum
+ */
+export declare const FilterOperator: {
+    readonly EQ: "EQ";
+    readonly GE: "GE";
+    readonly GT: "GT";
+    readonly LE: "LE";
+    readonly LT: "LT";
+    readonly NE: "NE";
+};
+/**
+ * @public
+ */
+export type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const CrawlerHistoryState: {
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+    readonly RUNNING: "RUNNING";
+    readonly STOPPED: "STOPPED";
+};
+/**
+ * @public
+ */
+export type CrawlerHistoryState = (typeof CrawlerHistoryState)[keyof typeof CrawlerHistoryState];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatisticEvaluationLevel: {
+    readonly COLUMN: "Column";
+    readonly DATASET: "Dataset";
+    readonly MULTICOLUMN: "Multicolumn";
+};
+/**
+ * @public
+ */
+export type StatisticEvaluationLevel = (typeof StatisticEvaluationLevel)[keyof typeof StatisticEvaluationLevel];
+/**
+ * @public
+ * @enum
+ */
+export declare const EnableHybridValues: {
+    readonly FALSE: "FALSE";
+    readonly TRUE: "TRUE";
+};
+/**
+ * @public
+ */
+export type EnableHybridValues = (typeof EnableHybridValues)[keyof typeof EnableHybridValues];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExistCondition: {
+    readonly MUST_EXIST: "MUST_EXIST";
+    readonly NONE: "NONE";
+    readonly NOT_EXIST: "NOT_EXIST";
+};
+/**
+ * @public
+ */
+export type ExistCondition = (typeof ExistCondition)[keyof typeof ExistCondition];
+/**
+ * @public
+ * @enum
+ */
+export declare const Comparator: {
+    readonly EQUALS: "EQUALS";
+    readonly GREATER_THAN: "GREATER_THAN";
+    readonly GREATER_THAN_EQUALS: "GREATER_THAN_EQUALS";
+    readonly LESS_THAN: "LESS_THAN";
+    readonly LESS_THAN_EQUALS: "LESS_THAN_EQUALS";
+};
+/**
+ * @public
+ */
+export type Comparator = (typeof Comparator)[keyof typeof Comparator];
+/**
+ * @public
+ * @enum
+ */
+export declare const Sort: {
+    readonly ASCENDING: "ASC";
+    readonly DESCENDING: "DESC";
+};
+/**
+ * @public
+ */
+export type Sort = (typeof Sort)[keyof typeof Sort];
+/**
+ * @public
+ * @enum
+ */
+export declare const ViewUpdateAction: {
+    readonly ADD: "ADD";
+    readonly ADD_OR_REPLACE: "ADD_OR_REPLACE";
+    readonly DROP: "DROP";
+    readonly REPLACE: "REPLACE";
+};
+/**
+ * @public
+ */
+export type ViewUpdateAction = (typeof ViewUpdateAction)[keyof typeof ViewUpdateAction];