@nice2dev/ui-tools 1.0.10

package/dist/data-warehouse.d.ts

@@ -0,0 +1,1097 @@
+/**
+ * @file data-warehouse.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-15.4 — Data Warehouse Explorer
+ *
+ * Types for warehouse browser: schema browser, data preview, query editor,
+ * saved queries, query history, cost estimation, optimization suggestions.
+ */
+/** Warehouse type */
+export type WarehouseType = 'snowflake' | 'bigquery' | 'redshift' | 'databricks' | 'athena' | 'synapse' | 'clickhouse' | 'duckdb' | 'trino' | 'presto' | 'spark' | 'hive' | 'custom';
+/** Query status */
+export type QueryStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/** Object type */
+export type DatabaseObjectType = 'database' | 'schema' | 'table' | 'view' | 'materializedView' | 'function' | 'procedure' | 'sequence' | 'type' | 'stream' | 'task' | 'pipe' | 'stage' | 'fileFormat';
+/** Warehouse explorer configuration */
+export interface WarehouseExplorerConfig {
+    /** Connection */
+    connection?: WarehouseConnection;
+    /** Theme */
+    theme?: WarehouseExplorerTheme;
+    /** Locale */
+    locale?: string;
+    /** Features */
+    features?: WarehouseFeatures;
+    /** Query editor config */
+    queryEditor?: QueryEditorConfig;
+    /** Schema browser config */
+    schemaBrowser?: SchemaBrowserConfig;
+    /** Data preview config */
+    dataPreview?: DataPreviewConfig;
+    /** History config */
+    historyConfig?: HistoryConfig;
+    /** Cost estimation config */
+    costConfig?: CostEstimationConfig;
+}
+/** Warehouse connection */
+export interface WarehouseConnection {
+    type: WarehouseType;
+    host?: string;
+    port?: number;
+    account?: string;
+    database?: string;
+    warehouse?: string;
+    schema?: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    role?: string;
+    authenticator?: string;
+    privateKey?: string;
+    privateKeyPassphrase?: string;
+    region?: string;
+    project?: string;
+    dataset?: string;
+    catalog?: string;
+    httpPath?: string;
+    timeout?: number;
+    poolSize?: number;
+    ssl?: boolean;
+    options?: Record<string, unknown>;
+}
+/** Warehouse explorer theme */
+export interface WarehouseExplorerTheme {
+    name?: string;
+    background?: string;
+    surface?: string;
+    primary?: string;
+    secondary?: string;
+    text?: string;
+    border?: string;
+    syntax?: SyntaxTheme;
+}
+/** Syntax theme */
+export interface SyntaxTheme {
+    keyword?: string;
+    string?: string;
+    number?: string;
+    comment?: string;
+    function?: string;
+    operator?: string;
+    variable?: string;
+    type?: string;
+    table?: string;
+    column?: string;
+}
+/** Warehouse features */
+export interface WarehouseFeatures {
+    queryEditor?: boolean;
+    schemaBrowser?: boolean;
+    dataPreview?: boolean;
+    queryHistory?: boolean;
+    savedQueries?: boolean;
+    costEstimation?: boolean;
+    queryOptimization?: boolean;
+    explain?: boolean;
+    profiling?: boolean;
+    scheduling?: boolean;
+    collaboration?: boolean;
+    versioning?: boolean;
+    notebooks?: boolean;
+}
+/** Query editor configuration */
+export interface QueryEditorConfig {
+    theme?: string;
+    fontSize?: number;
+    tabSize?: number;
+    wordWrap?: boolean;
+    lineNumbers?: boolean;
+    minimap?: boolean;
+    autoComplete?: AutoCompleteConfig;
+    formatting?: FormattingConfig;
+    shortcuts?: KeyboardShortcut[];
+    snippets?: QuerySnippet[];
+    maxQueryLength?: number;
+    timeout?: number;
+}
+/** Auto-complete configuration */
+export interface AutoCompleteConfig {
+    enabled?: boolean;
+    tables?: boolean;
+    columns?: boolean;
+    functions?: boolean;
+    keywords?: boolean;
+    snippets?: boolean;
+    schemas?: boolean;
+    delay?: number;
+    maxSuggestions?: number;
+    caseSensitive?: boolean;
+}
+/** Formatting configuration */
+export interface FormattingConfig {
+    uppercase?: boolean;
+    indentSize?: number;
+    lineBreakBeforeClause?: boolean;
+    commaPosition?: 'before' | 'after';
+    alignColumns?: boolean;
+}
+/** Keyboard shortcut */
+export interface KeyboardShortcut {
+    id: string;
+    key: string;
+    modifiers?: ('ctrl' | 'alt' | 'shift' | 'meta')[];
+    action: string;
+    description?: string;
+}
+/** Query snippet */
+export interface QuerySnippet {
+    id: string;
+    name: string;
+    prefix: string;
+    body: string;
+    description?: string;
+    category?: string;
+}
+/** Schema browser configuration */
+export interface SchemaBrowserConfig {
+    showSystemObjects?: boolean;
+    showColumns?: boolean;
+    showDataTypes?: boolean;
+    showRowCounts?: boolean;
+    showIndexes?: boolean;
+    showConstraints?: boolean;
+    showTriggers?: boolean;
+    expandLevel?: number;
+    filterPattern?: string;
+    sortBy?: 'name' | 'type' | 'size' | 'modified';
+    sortOrder?: 'asc' | 'desc';
+    refreshInterval?: number;
+}
+/** Data preview configuration */
+export interface DataPreviewConfig {
+    maxRows?: number;
+    maxColumns?: number;
+    sampling?: SamplingConfig;
+    formatting?: DataFormattingConfig;
+    pagination?: PaginationConfig;
+    export?: ExportConfig;
+}
+/** Sampling configuration */
+export interface SamplingConfig {
+    enabled?: boolean;
+    method?: 'first' | 'random' | 'tablesample';
+    size?: number;
+    seed?: number;
+}
+/** Data formatting configuration */
+export interface DataFormattingConfig {
+    dateFormat?: string;
+    timestampFormat?: string;
+    numberFormat?: NumberFormatConfig;
+    nullDisplay?: string;
+    truncateLength?: number;
+    booleanDisplay?: {
+        true: string;
+        false: string;
+    };
+}
+/** Number format configuration */
+export interface NumberFormatConfig {
+    locale?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    useGrouping?: boolean;
+}
+/** Pagination configuration */
+export interface PaginationConfig {
+    enabled?: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+}
+/** Export configuration */
+export interface ExportConfig {
+    formats?: ('csv' | 'json' | 'parquet' | 'excel')[];
+    maxRows?: number;
+    includeHeaders?: boolean;
+}
+/** History configuration */
+export interface HistoryConfig {
+    enabled?: boolean;
+    maxEntries?: number;
+    retentionDays?: number;
+    saveResults?: boolean;
+    maxResultSize?: number;
+}
+/** Cost estimation configuration */
+export interface CostEstimationConfig {
+    enabled?: boolean;
+    provider?: WarehouseType;
+    pricing?: PricingConfig;
+    showBeforeRun?: boolean;
+    warnThreshold?: number;
+    blockThreshold?: number;
+}
+/** Pricing configuration */
+export interface PricingConfig {
+    computePerCredit?: number;
+    storagePerTB?: number;
+    dataTransferPerGB?: number;
+    currency?: string;
+}
+/** Database catalog */
+export interface DatabaseCatalog {
+    databases: DatabaseInfo[];
+    defaultDatabase?: string;
+    refreshedAt?: Date;
+}
+/** Database info */
+export interface DatabaseInfo {
+    name: string;
+    type?: 'database' | 'catalog';
+    owner?: string;
+    created?: Date;
+    comment?: string;
+    schemas?: SchemaInfo[];
+    options?: Record<string, unknown>;
+}
+/** Schema info */
+export interface SchemaInfo {
+    name: string;
+    database?: string;
+    owner?: string;
+    created?: Date;
+    comment?: string;
+    isDefault?: boolean;
+    tables?: TableInfo[];
+    views?: ViewInfo[];
+    functions?: FunctionInfo[];
+    procedures?: ProcedureInfo[];
+    sequences?: SequenceInfo[];
+    streams?: StreamInfo[];
+    tasks?: TaskInfo[];
+}
+/** Table info */
+export interface TableInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    type: 'table' | 'external' | 'temporary' | 'transient';
+    owner?: string;
+    created?: Date;
+    modified?: Date;
+    rowCount?: number;
+    bytes?: number;
+    comment?: string;
+    columns: ColumnInfo[];
+    primaryKey?: PrimaryKeyInfo;
+    foreignKeys?: ForeignKeyInfo[];
+    indexes?: IndexInfo[];
+    partitioning?: PartitioningInfo;
+    clustering?: ClusteringInfo;
+    retention?: RetentionInfo;
+    tags?: TagInfo[];
+}
+/** Column info */
+export interface ColumnInfo {
+    name: string;
+    ordinalPosition: number;
+    dataType: string;
+    nullable: boolean;
+    defaultValue?: string;
+    comment?: string;
+    isPrimaryKey?: boolean;
+    isForeignKey?: boolean;
+    isPartitionKey?: boolean;
+    isClusteringKey?: boolean;
+    autoIncrement?: boolean;
+    collation?: string;
+    precision?: number;
+    scale?: number;
+    maxLength?: number;
+    tags?: TagInfo[];
+    statistics?: ColumnStatistics;
+}
+/** Column statistics */
+export interface ColumnStatistics {
+    distinctCount?: number;
+    nullCount?: number;
+    minValue?: unknown;
+    maxValue?: unknown;
+    avgLength?: number;
+    histogram?: HistogramBucket[];
+    topValues?: TopValue[];
+}
+/** Histogram bucket */
+export interface HistogramBucket {
+    lowerBound: unknown;
+    upperBound: unknown;
+    count: number;
+    distinctCount?: number;
+}
+/** Top value */
+export interface TopValue {
+    value: unknown;
+    count: number;
+    percentage: number;
+}
+/** Primary key info */
+export interface PrimaryKeyInfo {
+    name?: string;
+    columns: string[];
+}
+/** Foreign key info */
+export interface ForeignKeyInfo {
+    name?: string;
+    columns: string[];
+    referencedTable: string;
+    referencedSchema?: string;
+    referencedColumns: string[];
+    onDelete?: 'cascade' | 'restrict' | 'setNull' | 'setDefault' | 'noAction';
+    onUpdate?: 'cascade' | 'restrict' | 'setNull' | 'setDefault' | 'noAction';
+}
+/** Index info */
+export interface IndexInfo {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    type?: 'btree' | 'hash' | 'gin' | 'gist' | 'brin' | 'fulltext' | 'spatial';
+    predicate?: string;
+    includes?: string[];
+}
+/** Partitioning info */
+export interface PartitioningInfo {
+    type: 'range' | 'list' | 'hash' | 'time';
+    columns: string[];
+    granularity?: string;
+    partitions?: PartitionInfo[];
+}
+/** Partition info */
+export interface PartitionInfo {
+    name: string;
+    value?: unknown;
+    lowerBound?: unknown;
+    upperBound?: unknown;
+    rowCount?: number;
+    bytes?: number;
+}
+/** Clustering info */
+export interface ClusteringInfo {
+    columns: string[];
+    auto?: boolean;
+    depth?: number;
+    ratio?: number;
+}
+/** Retention info */
+export interface RetentionInfo {
+    timeTravel?: number;
+    failSafe?: number;
+    transient?: boolean;
+}
+/** Tag info */
+export interface TagInfo {
+    name: string;
+    value: string;
+    database?: string;
+    schema?: string;
+}
+/** View info */
+export interface ViewInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    type: 'view' | 'materializedView' | 'secure';
+    owner?: string;
+    created?: Date;
+    modified?: Date;
+    comment?: string;
+    columns: ColumnInfo[];
+    definition?: string;
+    isMaterialized?: boolean;
+    refreshSchedule?: string;
+    lastRefresh?: Date;
+}
+/** Function info */
+export interface FunctionInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    type: 'scalar' | 'table' | 'aggregate' | 'window';
+    language?: string;
+    owner?: string;
+    created?: Date;
+    comment?: string;
+    parameters: ParameterInfo[];
+    returnType: string;
+    definition?: string;
+    volatility?: 'immutable' | 'stable' | 'volatile';
+    nullHandling?: 'calledOnNull' | 'returnsNullOnNull' | 'strict';
+}
+/** Parameter info */
+export interface ParameterInfo {
+    name: string;
+    dataType: string;
+    mode: 'in' | 'out' | 'inout';
+    defaultValue?: string;
+    ordinalPosition: number;
+}
+/** Procedure info */
+export interface ProcedureInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    language?: string;
+    owner?: string;
+    created?: Date;
+    comment?: string;
+    parameters: ParameterInfo[];
+    definition?: string;
+    executeAs?: 'owner' | 'caller';
+}
+/** Sequence info */
+export interface SequenceInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    owner?: string;
+    currentValue?: number;
+    startValue?: number;
+    increment?: number;
+    minValue?: number;
+    maxValue?: number;
+    cycle?: boolean;
+    comment?: string;
+}
+/** Stream info (Snowflake) */
+export interface StreamInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    owner?: string;
+    sourceType: 'table' | 'view' | 'directory' | 'external';
+    sourceObject: string;
+    type: 'standard' | 'appendOnly' | 'insertOnly';
+    mode?: 'default' | 'insertOnly';
+    stale?: boolean;
+    staleAfter?: Date;
+    comment?: string;
+}
+/** Task info (Snowflake) */
+export interface TaskInfo {
+    name: string;
+    schema: string;
+    database?: string;
+    owner?: string;
+    warehouse?: string;
+    schedule?: string;
+    predecessors?: string[];
+    state: 'started' | 'suspended';
+    definition?: string;
+    condition?: string;
+    errorIntegration?: string;
+    lastRun?: Date;
+    nextRun?: Date;
+    comment?: string;
+}
+/** Query */
+export interface Query {
+    id: string;
+    name?: string;
+    content: string;
+    database?: string;
+    schema?: string;
+    warehouse?: string;
+    parameters?: QueryParameter[];
+    metadata?: QueryMetadata;
+}
+/** Query parameter */
+export interface QueryParameter {
+    name: string;
+    type: string;
+    value?: unknown;
+    defaultValue?: unknown;
+    required?: boolean;
+    description?: string;
+}
+/** Query metadata */
+export interface QueryMetadata {
+    created?: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    description?: string;
+    tags?: string[];
+    folder?: string;
+    shared?: boolean;
+    sharedWith?: string[];
+    version?: number;
+}
+/** Saved query */
+export interface SavedQuery extends Query {
+    folderId?: string;
+    starred?: boolean;
+    runCount?: number;
+    lastRun?: Date;
+    avgDuration?: number;
+    permissions?: QueryPermission[];
+}
+/** Query permission */
+export interface QueryPermission {
+    grantee: string;
+    granteeType: 'user' | 'role' | 'group';
+    permission: 'read' | 'write' | 'execute' | 'admin';
+}
+/** Query folder */
+export interface QueryFolder {
+    id: string;
+    name: string;
+    parentId?: string;
+    owner?: string;
+    shared?: boolean;
+    created?: Date;
+    modified?: Date;
+}
+/** Query execution request */
+export interface QueryExecutionRequest {
+    query: string;
+    database?: string;
+    schema?: string;
+    warehouse?: string;
+    role?: string;
+    parameters?: Record<string, unknown>;
+    limit?: number;
+    timeout?: number;
+    async?: boolean;
+    tags?: Record<string, string>;
+}
+/** Query execution result */
+export interface QueryExecutionResult {
+    queryId: string;
+    status: QueryStatus;
+    columns?: ResultColumn[];
+    rows?: unknown[][];
+    rowCount?: number;
+    totalRows?: number;
+    hasMore?: boolean;
+    nextToken?: string;
+    startTime?: Date;
+    endTime?: Date;
+    duration?: number;
+    bytesScanned?: number;
+    rowsScanned?: number;
+    partitionsScanned?: number;
+    partitionsTotal?: number;
+    cacheHit?: boolean;
+    warnings?: string[];
+    error?: QueryError;
+    metadata?: ResultMetadata;
+}
+/** Result column */
+export interface ResultColumn {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    precision?: number;
+    scale?: number;
+    collation?: string;
+}
+/** Query error */
+export interface QueryError {
+    code?: string;
+    message: string;
+    line?: number;
+    column?: number;
+    position?: number;
+    detail?: string;
+    hint?: string;
+}
+/** Result metadata */
+export interface ResultMetadata {
+    statementType?: StatementType;
+    affectedRows?: number;
+    sessionId?: string;
+    warehouseId?: string;
+    queryTag?: string;
+}
+/** Statement type */
+export type StatementType = 'select' | 'insert' | 'update' | 'delete' | 'merge' | 'create' | 'alter' | 'drop' | 'truncate' | 'grant' | 'revoke' | 'begin' | 'commit' | 'rollback' | 'copy' | 'unload' | 'explain' | 'describe' | 'show' | 'use' | 'set' | 'call' | 'other';
+/** Query history entry */
+export interface QueryHistoryEntry {
+    id: string;
+    query: string;
+    database?: string;
+    schema?: string;
+    warehouse?: string;
+    user?: string;
+    role?: string;
+    sessionId?: string;
+    status: QueryStatus;
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    rowsProduced?: number;
+    bytesScanned?: number;
+    bytesWritten?: number;
+    partitionsScanned?: number;
+    creditsUsed?: number;
+    errorCode?: string;
+    errorMessage?: string;
+    queryTag?: string;
+    queryHash?: string;
+}
+/** Query history filter */
+export interface QueryHistoryFilter {
+    startDate?: Date;
+    endDate?: Date;
+    user?: string;
+    database?: string;
+    schema?: string;
+    warehouse?: string;
+    status?: QueryStatus[];
+    minDuration?: number;
+    maxDuration?: number;
+    queryPattern?: string;
+    queryTag?: string;
+    limit?: number;
+    offset?: number;
+}
+/** Query history statistics */
+export interface QueryHistoryStats {
+    totalQueries: number;
+    successfulQueries: number;
+    failedQueries: number;
+    totalDuration: number;
+    avgDuration: number;
+    totalBytesScanned: number;
+    totalCreditsUsed?: number;
+    topUsers?: UserStats[];
+    topDatabases?: DatabaseStats[];
+    topQueries?: QueryStats[];
+}
+/** User stats */
+export interface UserStats {
+    user: string;
+    queryCount: number;
+    totalDuration: number;
+    avgDuration: number;
+    creditsUsed?: number;
+}
+/** Database stats */
+export interface DatabaseStats {
+    database: string;
+    queryCount: number;
+    totalDuration: number;
+    avgDuration: number;
+    bytesScanned: number;
+}
+/** Query stats */
+export interface QueryStats {
+    queryHash: string;
+    queryPattern?: string;
+    executionCount: number;
+    totalDuration: number;
+    avgDuration: number;
+    minDuration: number;
+    maxDuration: number;
+}
+/** Cost estimate */
+export interface CostEstimate {
+    queryId?: string;
+    query: string;
+    estimatedCredits?: number;
+    estimatedCost?: number;
+    currency?: string;
+    bytesToScan?: number;
+    partitionsToScan?: number;
+    estimatedDuration?: number;
+    confidence?: CostConfidence;
+    breakdown?: CostBreakdown;
+    recommendations?: CostRecommendation[];
+}
+/** Cost confidence */
+export type CostConfidence = 'high' | 'medium' | 'low' | 'unknown';
+/** Cost breakdown */
+export interface CostBreakdown {
+    compute?: number;
+    storage?: number;
+    dataTransfer?: number;
+    other?: number;
+    byWarehouse?: WarehouseCost[];
+    byTable?: TableCost[];
+}
+/** Warehouse cost */
+export interface WarehouseCost {
+    warehouse: string;
+    size: string;
+    credits: number;
+    cost: number;
+    duration: number;
+}
+/** Table cost */
+export interface TableCost {
+    table: string;
+    bytesScanned: number;
+    partitionsScanned: number;
+    cost: number;
+}
+/** Cost recommendation */
+export interface CostRecommendation {
+    type: RecommendationType;
+    severity: 'info' | 'warning' | 'critical';
+    message: string;
+    potentialSavings?: number;
+    suggestion?: string;
+    query?: string;
+}
+/** Recommendation type */
+export type RecommendationType = 'useSmallWarehouse' | 'useLargerWarehouse' | 'addClusteringKey' | 'addPartitioning' | 'useApproximateFunction' | 'addFilter' | 'avoidFullScan' | 'useMaterializedView' | 'useCache' | 'limitResults' | 'selectSpecificColumns' | 'optimizeJoin';
+/** Query optimization result */
+export interface QueryOptimizationResult {
+    originalQuery: string;
+    optimizedQuery?: string;
+    applied: boolean;
+    suggestions: OptimizationSuggestion[];
+    explain?: ExplainResult;
+    statistics?: QueryStatistics;
+}
+/** Optimization suggestion */
+export interface OptimizationSuggestion {
+    id: string;
+    type: OptimizationType;
+    severity: 'info' | 'warning' | 'critical';
+    message: string;
+    description?: string;
+    location?: QueryLocation;
+    suggestedFix?: string;
+    estimatedImprovement?: ImprovementEstimate;
+}
+/** Optimization type */
+export type OptimizationType = 'selectStar' | 'missingFilter' | 'inefficientJoin' | 'implicitCast' | 'functionOnColumn' | 'unnecessaryDistinct' | 'unnecessaryOrderBy' | 'cartesianProduct' | 'largeScan' | 'spillToDisk' | 'skewedData' | 'missingIndex' | 'outdatedStatistics' | 'suboptimalPlan';
+/** Query location */
+export interface QueryLocation {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    text?: string;
+}
+/** Improvement estimate */
+export interface ImprovementEstimate {
+    metric: 'duration' | 'cost' | 'bytes' | 'rows';
+    current: number;
+    estimated: number;
+    improvement: number;
+    improvementPercent: number;
+}
+/** Explain result */
+export interface ExplainResult {
+    format: 'text' | 'json' | 'tree' | 'visual';
+    plan: ExplainPlan | string;
+    statistics?: PlanStatistics;
+}
+/** Explain plan */
+export interface ExplainPlan {
+    operation: string;
+    description?: string;
+    cost?: PlanCost;
+    rows?: number;
+    children?: ExplainPlan[];
+    details?: Record<string, unknown>;
+}
+/** Plan cost */
+export interface PlanCost {
+    startup?: number;
+    total?: number;
+    rows?: number;
+    width?: number;
+}
+/** Plan statistics */
+export interface PlanStatistics {
+    planningTime?: number;
+    executionTime?: number;
+    totalCost?: number;
+    memoryUsed?: number;
+    diskUsed?: number;
+}
+/** Query statistics */
+export interface QueryStatistics {
+    compilationTime?: number;
+    executionTime?: number;
+    queueTime?: number;
+    rowsProduced?: number;
+    rowsScanned?: number;
+    bytesScanned?: number;
+    bytesWritten?: number;
+    bytesSpilled?: number;
+    partitionsScanned?: number;
+    partitionsTotal?: number;
+    filesScanned?: number;
+    remoteReads?: number;
+    localReads?: number;
+    cacheHits?: number;
+    spillToDisk?: boolean;
+    networkBytes?: number;
+}
+/** Snowflake-specific features */
+export interface SnowflakeFeatures {
+    timeTravel?: TimeTravelConfig;
+    cloning?: CloningConfig;
+    dataMasking?: DataMaskingConfig;
+    rowAccessPolicy?: RowAccessPolicyConfig;
+    streams?: StreamConfig;
+    tasks?: TaskConfig;
+    tags?: TagConfig;
+}
+/** Time travel configuration */
+export interface TimeTravelConfig {
+    enabled?: boolean;
+    retentionDays?: number;
+    queryAtTimestamp?: Date;
+    queryBeforeStatement?: string;
+    queryAtOffset?: string;
+}
+/** Cloning configuration */
+export interface CloningConfig {
+    sourceObject?: string;
+    targetObject?: string;
+    atTimestamp?: Date;
+    atOffset?: string;
+}
+/** Data masking configuration */
+export interface DataMaskingConfig {
+    policies?: MaskingPolicy[];
+}
+/** Masking policy */
+export interface MaskingPolicy {
+    name: string;
+    database?: string;
+    schema?: string;
+    inputDataType: string;
+    returnDataType: string;
+    body: string;
+    column?: string;
+    table?: string;
+}
+/** Row access policy configuration */
+export interface RowAccessPolicyConfig {
+    policies?: RowAccessPolicy[];
+}
+/** Row access policy */
+export interface RowAccessPolicy {
+    name: string;
+    database?: string;
+    schema?: string;
+    signature: ParameterInfo[];
+    body: string;
+    table?: string;
+    columns?: string[];
+}
+/** Stream configuration */
+export interface StreamConfig {
+    name?: string;
+    sourceTable?: string;
+    appendOnly?: boolean;
+    insertOnly?: boolean;
+    showInitialRows?: boolean;
+}
+/** Task configuration */
+export interface TaskConfig {
+    name?: string;
+    warehouse?: string;
+    schedule?: string;
+    predecessors?: string[];
+    allowOverlap?: boolean;
+    suspendAfterFailures?: number;
+    errorIntegration?: string;
+}
+/** Tag configuration */
+export interface TagConfig {
+    tags?: Tag[];
+}
+/** Tag */
+export interface Tag {
+    name: string;
+    database?: string;
+    schema?: string;
+    allowedValues?: string[];
+    comment?: string;
+}
+/** BigQuery-specific features */
+export interface BigQueryFeatures {
+    partitioning?: BigQueryPartitioning;
+    clustering?: string[];
+    tableExpiration?: number;
+    routines?: BigQueryRoutine[];
+    mlModels?: BigQueryMLModel[];
+}
+/** BigQuery partitioning */
+export interface BigQueryPartitioning {
+    type: 'time' | 'range' | 'ingestionTime';
+    field?: string;
+    granularity?: 'hour' | 'day' | 'month' | 'year';
+    rangeStart?: number;
+    rangeEnd?: number;
+    rangeInterval?: number;
+    expirationMs?: number;
+    requirePartitionFilter?: boolean;
+}
+/** BigQuery routine */
+export interface BigQueryRoutine {
+    name: string;
+    type: 'function' | 'procedure' | 'tableFunction';
+    language: 'sql' | 'javascript';
+    arguments: RoutineArgument[];
+    returnType?: string;
+    returnTableType?: TableFieldSchema[];
+    definition: string;
+    description?: string;
+}
+/** Routine argument */
+export interface RoutineArgument {
+    name: string;
+    dataType: string;
+    mode?: 'in' | 'out' | 'inout';
+}
+/** Table field schema */
+export interface TableFieldSchema {
+    name: string;
+    type: string;
+    mode?: 'nullable' | 'required' | 'repeated';
+    fields?: TableFieldSchema[];
+    description?: string;
+}
+/** BigQuery ML model */
+export interface BigQueryMLModel {
+    name: string;
+    modelType: string;
+    trainingRuns?: MLTrainingRun[];
+    featureColumns?: string[];
+    labelColumn?: string;
+    created?: Date;
+    modified?: Date;
+}
+/** ML training run */
+export interface MLTrainingRun {
+    startTime: Date;
+    trainingOptions: Record<string, unknown>;
+    evaluationMetrics?: Record<string, number>;
+    dataSplitResult?: DataSplitResult;
+}
+/** Data split result */
+export interface DataSplitResult {
+    trainingTable?: string;
+    evaluationTable?: string;
+}
+/** Redshift-specific features */
+export interface RedshiftFeatures {
+    distStyle?: 'auto' | 'even' | 'key' | 'all';
+    distKey?: string;
+    sortKeys?: SortKey[];
+    encoding?: ColumnEncoding[];
+    spectrum?: SpectrumConfig;
+    workloadManagement?: WLMConfig;
+}
+/** Sort key */
+export interface SortKey {
+    column: string;
+    type?: 'compound' | 'interleaved';
+}
+/** Column encoding */
+export interface ColumnEncoding {
+    column: string;
+    encoding: string;
+}
+/** Spectrum configuration */
+export interface SpectrumConfig {
+    externalSchemas?: ExternalSchema[];
+    externalTables?: ExternalTable[];
+}
+/** External schema */
+export interface ExternalSchema {
+    name: string;
+    database: string;
+    region?: string;
+    iamRole?: string;
+    catalogId?: string;
+}
+/** External table */
+export interface ExternalTable {
+    name: string;
+    schema: string;
+    location: string;
+    fileFormat: string;
+    columns: ColumnInfo[];
+}
+/** WLM configuration */
+export interface WLMConfig {
+    queues?: WLMQueue[];
+    autoWLM?: boolean;
+}
+/** WLM queue */
+export interface WLMQueue {
+    name: string;
+    concurrency: number;
+    memory: number;
+    timeout?: number;
+    userGroups?: string[];
+    queryGroups?: string[];
+    priority?: 'normal' | 'high' | 'highest' | 'low' | 'lowest';
+}
+/** Databricks-specific features */
+export interface DatabricksFeatures {
+    deltaLake?: DeltaLakeConfig;
+    unity?: UnityCatalogConfig;
+    mlflow?: MLflowConfig;
+    photon?: boolean;
+}
+/** Delta Lake configuration */
+export interface DeltaLakeConfig {
+    optimize?: OptimizeConfig;
+    vacuum?: VacuumConfig;
+    timeTravel?: DeltaTimeTravelConfig;
+    changeDataFeed?: boolean;
+}
+/** Optimize configuration */
+export interface OptimizeConfig {
+    zOrderBy?: string[];
+    auto?: boolean;
+    targetSize?: number;
+}
+/** Vacuum configuration */
+export interface VacuumConfig {
+    retentionHours?: number;
+    dryRun?: boolean;
+}
+/** Delta time travel configuration */
+export interface DeltaTimeTravelConfig {
+    version?: number;
+    timestamp?: Date;
+}
+/** Unity Catalog configuration */
+export interface UnityCatalogConfig {
+    catalog?: string;
+    schemas?: string[];
+    grants?: GrantInfo[];
+}
+/** Grant info */
+export interface GrantInfo {
+    principal: string;
+    principalType: 'user' | 'group' | 'servicePrincipal';
+    privilege: string;
+    objectType: string;
+    objectName: string;
+}
+/** MLflow configuration */
+export interface MLflowConfig {
+    trackingUri?: string;
+    registryUri?: string;
+    experiments?: MLflowExperiment[];
+}
+/** MLflow experiment */
+export interface MLflowExperiment {
+    id: string;
+    name: string;
+    artifact: string;
+    lifecycleStage: 'active' | 'deleted';
+    lastUpdateTime?: Date;
+}
+//# sourceMappingURL=data-warehouse.d.ts.map