@vertesia/common 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260804.124748Z

package/src/data-platform.ts

@@ -1,3 +1,4 @@
+import type { AppDashboardDefinitionSchema } from './api-schemas/app-runtime.js';
 /**
  * Data Platform Types
  *
@@ -5,7 +6,87 @@
  * Supports AI-manageable schemas and multi-table atomic operations.
  */
 
-import type { BaseObject } from './store/common.js';
+import type { z } from 'zod';
+import type {
+    CreateDashboardPayloadSchema,
+    CreateDashboardSnapshotPayloadSchema,
+    DashboardArchiveResultSchema,
+    DashboardBulkArchiveResultSchema,
+    DashboardBulkDeleteResultSchema,
+    DashboardDataSourceSchema,
+    DashboardElasticsearchDslSchema,
+    DashboardElasticsearchResultMappingSchema,
+    DashboardItemSchema,
+    DashboardLayoutSchema,
+    DashboardPanelPositionSchema,
+    DashboardPanelSchema,
+    DashboardQuerySchema,
+    DashboardSchema,
+    DashboardSqlDataSourceSchema,
+    DashboardStatusSchema,
+    DashboardStoreElasticsearchDataSourceSchema,
+    DashboardVersionItemSchema,
+    DashboardVersioningPayloadSchema,
+    DashboardVersioningStatusResponseSchema,
+    DashboardVersionSchema,
+    PromoteDashboardVersionPayloadSchema,
+    UpdateDashboardPayloadSchema,
+} from './api-schemas/dashboard.js';
+import type {
+    AlterTableOperationSchema,
+    AlterTablePayloadSchema,
+    BatchQueryPayloadSchema,
+    BatchQueryResultItemSchema,
+    BatchQueryResultSchema,
+    CreateDataStorePayloadSchema,
+    CreateSnapshotPayloadSchema,
+    CreateTablePayloadSchema,
+    CreateTablesPayloadSchema,
+    DataColumnForAISchema,
+    DataColumnSchema,
+    DataColumnTypeSchema,
+    DataForeignKeyForAISchema,
+    DataForeignKeySchema,
+    DataIndexSchema,
+    DataRelationshipForAISchema,
+    DataRelationshipSchema,
+    DataRelationshipTypeSchema,
+    DataSchemaForAISchema,
+    DataSchemaSchema,
+    DataStoreArchiveResultSchema,
+    DataStoreDownloadInfoSchema,
+    DataStoreFullSchemaResponseSchema,
+    DataStoreItemSchema,
+    DataStoreMutateRowsPayloadSchema,
+    DataStoreMutateRowsResultSchema,
+    DataStoreSchema,
+    DataStoreSchemaResponseSchema,
+    DataStoreStatusSchema,
+    DataStoreTableDetailSchema,
+    DataStoreTableDropResultSchema,
+    DataStoreVersionSchema,
+    DataStoreVersionTableStateSchema,
+    DataTableForAISchema,
+    DataTableSchema,
+    DataTableSemanticTypeSchema,
+    DataTableSummarySchema,
+    GetDataStoreTableQuerySchema,
+    ImportDataFormatSchema,
+    ImportDataPayloadSchema,
+    ImportDataSourceSchema,
+    ImportJobSchema,
+    ImportStatusSchema,
+    ImportTableDataSchema,
+    ListDataStoreVersionsQuerySchema,
+    QueryPayloadSchema,
+    QueryResultColumnSchema,
+    QueryResultSchema,
+    QueryValidationErrorSchema,
+    QueryValidationPayloadSchema,
+    QueryValidationResultSchema,
+    SemanticColumnTypeSchema,
+    UpdateSchemaPayloadSchema,
+} from './api-schemas/data-store.js';
 
 // ============================================================================
 // Column Types
@@ -14,34 +95,38 @@ import type { BaseObject } from './store/common.js';
 /**
  * Supported column data types for DuckDB tables.
  */
-export enum DataColumnType {
-    STRING = 'STRING',
-    INTEGER = 'INTEGER',
-    BIGINT = 'BIGINT',
-    FLOAT = 'FLOAT',
-    DOUBLE = 'DOUBLE',
-    DECIMAL = 'DECIMAL',
-    BOOLEAN = 'BOOLEAN',
-    DATE = 'DATE',
-    TIMESTAMP = 'TIMESTAMP',
-    JSON = 'JSON',
-}
+export const DataColumnType = {
+    STRING: 'STRING',
+    INTEGER: 'INTEGER',
+    BIGINT: 'BIGINT',
+    FLOAT: 'FLOAT',
+    DOUBLE: 'DOUBLE',
+    DECIMAL: 'DECIMAL',
+    BOOLEAN: 'BOOLEAN',
+    DATE: 'DATE',
+    TIMESTAMP: 'TIMESTAMP',
+    JSON: 'JSON',
+} as const;
+
+export type DataColumnType = z.infer<typeof DataColumnTypeSchema>;
 
 /**
  * Semantic types that provide AI agents with context about column meaning.
  */
-export enum SemanticColumnType {
-    EMAIL = 'email',
-    PHONE = 'phone',
-    URL = 'url',
-    CURRENCY = 'currency',
-    PERCENTAGE = 'percentage',
-    PERSON_NAME = 'person_name',
-    ADDRESS = 'address',
-    COUNTRY = 'country',
-    DATE_ISO = 'date_iso',
-    IDENTIFIER = 'identifier',
-}
+export const SemanticColumnType = {
+    EMAIL: 'email',
+    PHONE: 'phone',
+    URL: 'url',
+    CURRENCY: 'currency',
+    PERCENTAGE: 'percentage',
+    PERSON_NAME: 'person_name',
+    ADDRESS: 'address',
+    COUNTRY: 'country',
+    DATE_ISO: 'date_iso',
+    IDENTIFIER: 'identifier',
+} as const;
+
+export type SemanticColumnType = z.infer<typeof SemanticColumnTypeSchema>;
 
 /**
  * Mapping from DataColumnType to DuckDB SQL types.
@@ -66,150 +151,49 @@ export const DATA_COLUMN_TYPE_TO_DUCKDB: Record<DataColumnType, string> = {
 /**
  * Column definition for a data table.
  */
-export interface DataColumn {
-    /** Column name (must be valid SQL identifier) */
-    name: string;
-    /** Data type */
-    type: DataColumnType;
-    /** Human-readable description */
-    description?: string;
-    /** Whether the column allows NULL values */
-    nullable?: boolean;
-    /** Default value (SQL expression as string) */
-    default?: string;
-    /** Whether this is the primary key */
-    primary_key?: boolean;
-    /** Whether this column should use a sequence-backed auto-increment default */
-    auto_increment?: boolean;
-    /** Whether values must be unique */
-    unique?: boolean;
-    /** Semantic type for AI understanding */
-    semantic_type?: SemanticColumnType;
-    /** Example values for AI context */
-    examples?: string[];
-}
+export type DataColumn = z.infer<typeof DataColumnSchema>;
 
 /**
  * Foreign key constraint definition.
  */
-export interface DataForeignKey {
-    /** Column in this table */
-    column: string;
-    /** Referenced table name */
-    references_table: string;
-    /** Referenced column name */
-    references_column: string;
-    /** Action on delete */
-    on_delete?: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-}
+export type DataForeignKey = z.infer<typeof DataForeignKeySchema>;
 
 /**
  * Index definition for a table.
  */
-export interface DataIndex {
-    /** Index name */
-    name: string;
-    /** Columns included in the index */
-    columns: string[];
-    /** Whether the index enforces uniqueness */
-    unique?: boolean;
-}
+export type DataIndex = z.infer<typeof DataIndexSchema>;
 
 /**
  * Semantic type categorization for tables.
  */
-export type DataTableSemanticType = 'dimension' | 'fact' | 'bridge' | 'staging';
+export type DataTableSemanticType = z.infer<typeof DataTableSemanticTypeSchema>;
 
 /**
  * Table definition within a data schema.
  */
-export interface DataTable {
-    /** Table name (must be valid SQL identifier) */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** Column definitions */
-    columns: DataColumn[];
-    /** Foreign key constraints */
-    foreign_keys?: DataForeignKey[];
-    /** Index definitions */
-    indexes?: DataIndex[];
-    /** Semantic categorization for AI understanding */
-    semantic_type?: DataTableSemanticType;
-    /** Tags for organization */
-    tags: string[];
-    /** Current row count (updated after imports) */
-    row_count?: number;
-    /** Table creation timestamp */
-    created_at?: string;
-    /** Last modification timestamp */
-    updated_at?: string;
-}
+export type DataTable = z.infer<typeof DataTableSchema>;
 
 /**
  * Summary view of a data table (for listings).
  */
-export interface DataTableSummary {
-    /** Table name */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** Semantic categorization for AI understanding */
-    semantic_type?: DataTableSemanticType;
-    /** Number of columns */
-    column_count: number;
-    /** Current row count */
-    row_count?: number;
-    /** Tags for organization */
-    tags: string[];
-}
+export type DataTableSummary = z.infer<typeof DataTableSummarySchema>;
 
 /**
  * Relationship type between tables.
  */
-export type DataRelationshipType = 'one-to-one' | 'one-to-many' | 'many-to-many';
+export type DataRelationshipType = z.infer<typeof DataRelationshipTypeSchema>;
 
 /**
  * Semantic relationship between tables for AI understanding.
  */
-export interface DataRelationship {
-    /** Relationship name */
-    name: string;
-    /** Source table */
-    from_table: string;
-    /** Source column */
-    from_column: string;
-    /** Target table */
-    to_table: string;
-    /** Target column */
-    to_column: string;
-    /** Relationship cardinality */
-    relationship_type: DataRelationshipType;
-    /** Human-readable description */
-    description?: string;
-}
+export type DataRelationship = z.infer<typeof DataRelationshipSchema>;
 
 /**
  * Complete schema definition for a data store.
  */
-export interface DataSchema {
-    /** Semantic version (e.g., "1.2.0") */
-    version: string;
-    /** Schema description */
-    description?: string;
-    /** Table definitions */
-    tables: DataTable[];
-    /** Relationship definitions */
-    relationships: DataRelationship[];
-    /** Last update timestamp */
-    updated_at: string;
-    /** User/agent who last updated */
-    updated_by?: string;
-}
+export type DataSchema = z.infer<typeof DataSchemaSchema>;
 
-export interface DataStoreFullSchemaResponse extends DataSchema {
-    schema_format: 'full';
-}
+export type DataStoreFullSchemaResponse = z.infer<typeof DataStoreFullSchemaResponseSchema>;
 
 // ============================================================================
 // Data Store Types
@@ -218,50 +202,24 @@ export interface DataStoreFullSchemaResponse extends DataSchema {
 /**
  * Data store lifecycle status.
  */
-export enum DataStoreStatus {
-    /** Store is being created */
-    CREATING = 'creating',
-    /** Store is active and usable */
-    ACTIVE = 'active',
-    /** Store encountered an error */
-    ERROR = 'error',
-    /** Store has been archived (soft deleted) */
-    ARCHIVED = 'archived',
-}
+export const DataStoreStatus = {
+    CREATING: 'creating',
+    ACTIVE: 'active',
+    ERROR: 'error',
+    ARCHIVED: 'archived',
+} as const;
+
+export type DataStoreStatus = z.infer<typeof DataStoreStatusSchema>;
 
 /**
  * Summary view of a data store (for listings).
  */
-export interface DataStoreItem extends BaseObject {
-    /** Current status */
-    status: DataStoreStatus;
-    /** Current schema version */
-    schema_version: string;
-    /** Number of tables */
-    table_count: number;
-    /** Total rows across all tables */
-    total_rows: number;
-    /** Storage size in bytes */
-    storage_bytes: number;
-    /** Last import timestamp */
-    last_import_at?: string;
-    /** Number of versions stored */
-    version_count: number;
-    /** Tags for organization */
-    tags: string[];
-}
+export type DataStoreItem = z.infer<typeof DataStoreItemSchema>;
 
 /**
  * Full data store with schema details.
  */
-export interface DataStore extends DataStoreItem {
-    /** Complete schema definition */
-    schema: DataSchema;
-    /** GCS bucket name */
-    gcs_bucket: string;
-    /** Path prefix within the bucket */
-    gcs_path: string;
-}
+export type DataStore = z.infer<typeof DataStoreSchema>;
 
 // ============================================================================
 // Version Types
@@ -270,49 +228,16 @@ export interface DataStore extends DataStoreItem {
 /**
  * Table state within a version.
  */
-export interface DataStoreVersionTableState {
-    /** Row count at this version */
-    row_count: number;
-    /** Content checksum */
-    checksum: string;
-}
+export type DataStoreVersionTableState = z.infer<typeof DataStoreVersionTableStateSchema>;
 
 /**
  * A point-in-time version of a data store.
  */
-export interface DataStoreVersion {
-    /** Version ID */
-    id: string;
-    /** Parent store ID */
-    store_id: string;
-    /** Commit message */
-    message: string;
-    /** Schema version at this point */
-    schema_version: string;
-    /** Table states at this version */
-    tables: Record<string, DataStoreVersionTableState>;
-    /** Creation timestamp */
-    created_at: string;
-    /** User/agent who created */
-    created_by?: string;
-    /** GCS object generation number */
-    gcs_generation: number;
-    /** Timestamp-based ID used for GCS path (internal) */
-    gcs_path_id?: string;
-    /** Whether this is a named snapshot */
-    is_snapshot?: boolean;
-    /** Snapshot name (if is_snapshot) */
-    snapshot_name?: string;
-}
+export type DataStoreVersion = z.infer<typeof DataStoreVersionSchema>;
 
-export interface ListDataStoreVersionsQuery {
-    limit?: number;
-    snapshots_only?: boolean;
-}
+export type ListDataStoreVersionsQuery = z.infer<typeof ListDataStoreVersionsQuerySchema>;
 
-export interface GetDataStoreTableQuery {
-    sample?: boolean;
-}
+export type GetDataStoreTableQuery = z.infer<typeof GetDataStoreTableQuerySchema>;
 
 // ============================================================================
 // Import Types
@@ -321,48 +246,20 @@ export interface GetDataStoreTableQuery {
 /**
  * Import job status.
  */
-export enum ImportStatus {
-    /** Job is queued */
-    PENDING = 'pending',
-    /** Job is running */
-    PROCESSING = 'processing',
-    /** Job completed successfully */
-    COMPLETED = 'completed',
-    /** Job failed */
-    FAILED = 'failed',
-    /** Job was rolled back */
-    ROLLED_BACK = 'rolled_back',
-}
+export const ImportStatus = {
+    PENDING: 'pending',
+    PROCESSING: 'processing',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    ROLLED_BACK: 'rolled_back',
+} as const;
+
+export type ImportStatus = z.infer<typeof ImportStatusSchema>;
 
 /**
  * Import job tracking.
  */
-export interface ImportJob {
-    /** Job ID */
-    id: string;
-    /** Parent store ID */
-    store_id: string;
-    /** Current status */
-    status: ImportStatus;
-    /** Tables being imported */
-    tables: string[];
-    /** Import mode */
-    mode: 'append' | 'replace';
-    /** Commit message */
-    message?: string;
-    /** Error message (if failed) */
-    error?: string;
-    /** Total rows imported */
-    rows_imported: number;
-    /** Job start timestamp */
-    started_at: string;
-    /** Job completion timestamp */
-    completed_at?: string;
-    /** Resulting version ID (if completed) */
-    version_id?: string;
-    /** User/agent who initiated */
-    created_by?: string;
-}
+export type ImportJob = z.infer<typeof ImportJobSchema>;
 
 // ============================================================================
 // API Payloads
@@ -371,52 +268,21 @@ export interface ImportJob {
 /**
  * Payload for creating a new data store.
  */
-export interface CreateDataStorePayload {
-    /** Store name (unique within project) */
-    name: string;
-    /** Store description */
-    description?: string;
-    /** Tags for organization */
-    tags?: string[];
-}
+export type CreateDataStorePayload = z.infer<typeof CreateDataStorePayloadSchema>;
 
 /**
  * Payload for creating a new table.
  */
-export interface CreateTablePayload {
-    /** Table name */
-    name: string;
-    /** Table description */
-    description?: string;
-    /** Column definitions (at least one required) */
-    columns: DataColumn[];
-    /** Foreign key constraints */
-    foreign_keys?: DataForeignKey[];
-    /** Index definitions */
-    indexes?: DataIndex[];
-    /** Semantic type */
-    semantic_type?: DataTableSemanticType;
-    /** Tags */
-    tags?: string[];
-}
+export type CreateTablePayload = z.infer<typeof CreateTablePayloadSchema>;
 
 /**
  * Payload for creating multiple tables atomically.
  */
-export interface CreateTablesPayload {
-    /** Table definitions to create */
-    tables: CreateTablePayload[];
-    /** Commit message */
-    message: string;
-}
+export type CreateTablesPayload = z.infer<typeof CreateTablesPayloadSchema>;
 
-export interface QueryValidationPayload {
-    queries: Array<{ name: string; sql: string }>;
-}
+export type QueryValidationPayload = z.infer<typeof QueryValidationPayloadSchema>;
 
-export interface BatchQueryPayload {
-    queries: Array<{ name: string; sql: string; limit?: number }>;
-}
+export type BatchQueryPayload = z.infer<typeof BatchQueryPayloadSchema>;
 
 /**
  * Schema change operation types.
@@ -424,35 +290,17 @@ export interface BatchQueryPayload {
 /**
  * @discriminator op
  */
-export type AlterTableOperation =
-    | { op: 'add_column'; column: DataColumn }
-    | { op: 'drop_column'; column: string }
-    | { op: 'rename_column'; from: string; to: string }
-    | { op: 'modify_column'; column: string; updates: Partial<Omit<DataColumn, 'name'>> };
+export type AlterTableOperation = z.infer<typeof AlterTableOperationSchema>;
 
 /**
  * Payload for altering a table schema.
  */
-export interface AlterTablePayload {
-    /** List of schema changes to apply */
-    changes: AlterTableOperation[];
-}
+export type AlterTablePayload = z.infer<typeof AlterTablePayloadSchema>;
 
 /**
  * Payload for AI-driven bulk schema updates.
  */
-export interface UpdateSchemaPayload {
-    /** Updated schema description */
-    description?: string;
-    /** Tables to create or update */
-    tables?: CreateTablePayload[];
-    /** Relationships to set */
-    relationships?: DataRelationship[];
-    /** Tables to drop */
-    drop_tables?: string[];
-    /** Commit message (required) */
-    message: string;
-}
+export type UpdateSchemaPayload = z.infer<typeof UpdateSchemaPayloadSchema>;
 
 /**
  * Data source for import.
@@ -461,183 +309,83 @@ export interface UpdateSchemaPayload {
  * - 'url': data at an HTTPS URL
  * - 'artifact': data from workflow artifact (resolved to GCS by tool)
  */
-export type ImportDataSource = 'inline' | 'gcs' | 'url' | 'artifact';
+export type ImportDataSource = z.infer<typeof ImportDataSourceSchema>;
 
 /**
  * Data format for external sources.
  */
-export type ImportDataFormat = 'json' | 'csv' | 'parquet';
+export type ImportDataFormat = z.infer<typeof ImportDataFormatSchema>;
 
 /**
  * Table data specification for import.
  */
-export interface ImportTableData {
-    /** Where the data comes from */
-    source: ImportDataSource;
-    /** Inline data (when source is 'inline') */
-    data?: Record<string, unknown>[];
-    /** URI for external data (gcs: gs://..., url: https://..., artifact: out/file.csv) */
-    uri?: string;
-    /** Data format for external sources */
-    format?: ImportDataFormat;
-}
+export type ImportTableData = z.infer<typeof ImportTableDataSchema>;
 
 /**
  * Payload for importing data into tables.
  */
-export interface ImportDataPayload {
-    /** Map of table name to data specification */
-    tables: Record<string, ImportTableData>;
-    /** Import mode */
-    mode: 'append' | 'replace';
-    /** Commit message */
-    message: string;
-}
+export type ImportDataPayload = z.infer<typeof ImportDataPayloadSchema>;
 
 /**
  * Payload for creating a named snapshot.
  */
-export interface CreateSnapshotPayload {
-    /** Snapshot name (must be unique within store) */
-    name: string;
-    /** Snapshot description */
-    message: string;
-}
+export type CreateSnapshotPayload = z.infer<typeof CreateSnapshotPayloadSchema>;
 
 /**
  * Payload for executing a query.
  */
-export interface QueryPayload {
-    /** SQL query (SELECT only) */
-    sql: string;
-    /** Query parameters (for prepared statements) */
-    params?: Record<string, unknown>;
-    /** Maximum rows to return */
-    limit?: number;
-    /** Query against a specific version (optional) */
-    version_id?: string;
-}
+export type QueryPayload = z.infer<typeof QueryPayloadSchema>;
 
 /**
  * Payload for mutating data rows with a single SQL statement.
  */
-export interface DataStoreMutateRowsPayload {
-    /** SQL statement. Only UPDATE and DELETE statements are accepted. */
-    sql: string;
-    /** Commit message recorded on the resulting data store version. */
-    message: string;
-    /** Allow UPDATE/DELETE statements without a WHERE clause. Defaults to false. */
-    allow_full_table?: boolean;
-}
+export type DataStoreMutateRowsPayload = z.infer<typeof DataStoreMutateRowsPayloadSchema>;
 
 /**
  * Result from mutating rows in a data store.
  */
-export interface DataStoreMutateRowsResult {
-    /** Resulting data store version ID */
-    version_id: string;
-    /** Tables affected by the statement */
-    affected_tables: string[];
-    /** Current row counts for affected tables after the mutation */
-    row_counts: Record<string, number>;
-    /** Statement execution time in milliseconds */
-    execution_time_ms: number;
-}
+export type DataStoreMutateRowsResult = z.infer<typeof DataStoreMutateRowsResultSchema>;
 
 /**
  * Column metadata in query results.
  */
-export interface QueryResultColumn {
-    /** Column name */
-    name: string;
-    /** Column type */
-    type: string;
-}
+export type QueryResultColumn = z.infer<typeof QueryResultColumnSchema>;
 
 /**
  * Query execution result.
  */
-export interface QueryResult {
-    /** Column metadata */
-    columns: QueryResultColumn[];
-    /** Result rows */
-    rows: Record<string, unknown>[];
-    /** Number of rows returned */
-    row_count: number;
-    /** Query execution time in milliseconds */
-    execution_time_ms: number;
-    /** Error message if query failed (used in batch queries) */
-    error?: string;
-}
+export type QueryResult = z.infer<typeof QueryResultSchema>;
 
-export interface BatchQueryResultItem extends QueryResult {
-    name: string;
-}
+export type BatchQueryResultItem = z.infer<typeof BatchQueryResultItemSchema>;
 
-export interface BatchQueryResult {
-    results: BatchQueryResultItem[];
-}
+export type BatchQueryResult = z.infer<typeof BatchQueryResultSchema>;
 
-export interface QueryValidationError {
-    query: string;
-    error: string;
-}
+export type QueryValidationError = z.infer<typeof QueryValidationErrorSchema>;
 
-export interface QueryValidationResult {
-    valid: boolean;
-    errors: QueryValidationError[];
-}
+export type QueryValidationResult = z.infer<typeof QueryValidationResultSchema>;
 
-export interface DataStoreDownloadInfo {
-    url: string;
-    gcs_generation: number;
-    schema_version: string;
-    store_id: string;
-    store_name: string;
-    tables: string[];
-    expires_in: number;
-}
+export type DataStoreDownloadInfo = z.infer<typeof DataStoreDownloadInfoSchema>;
 
-export interface DataStoreArchiveResult {
-    id: string;
-    status: DataStoreStatus;
-}
+export type DataStoreArchiveResult = z.infer<typeof DataStoreArchiveResultSchema>;
 
 /**
  * @discriminator schema_format
  */
-export type DataStoreSchemaResponse = DataStoreFullSchemaResponse | DataSchemaForAI;
+export type DataStoreSchemaResponse = z.infer<typeof DataStoreSchemaResponseSchema>;
 
-export interface DataStoreTableDetail extends DataTable {
-    sample_data?: Record<string, unknown>[];
-}
+export type DataStoreTableDetail = z.infer<typeof DataStoreTableDetailSchema>;
 
-export interface DataStoreTableDropResult {
-    dropped: string;
-}
+export type DataStoreTableDropResult = z.infer<typeof DataStoreTableDropResultSchema>;
 
-export interface DashboardArchiveResult {
-    id: string;
-    status: DashboardStatus;
-}
+export type DashboardArchiveResult = z.infer<typeof DashboardArchiveResultSchema>;
 
-export interface DashboardBulkArchiveResult {
-    archived: number;
-    failed: number;
-}
+export type DashboardBulkArchiveResult = z.infer<typeof DashboardBulkArchiveResultSchema>;
 
-export interface DashboardBulkDeleteResult {
-    deleted: number;
-    failed: number;
-}
+export type DashboardBulkDeleteResult = z.infer<typeof DashboardBulkDeleteResultSchema>;
 
-export interface DashboardVersioningStatusResponse {
-    versioning_enabled: boolean;
-}
+export type DashboardVersioningStatusResponse = z.infer<typeof DashboardVersioningStatusResponseSchema>;
 
-export interface DashboardVersioningPayload {
-    enabled: boolean;
-}
+export type DashboardVersioningPayload = z.infer<typeof DashboardVersioningPayloadSchema>;
 
 // ============================================================================
 // AI Agent Interface
@@ -646,80 +394,28 @@ export interface DashboardVersioningPayload {
 /**
  * Simplified column representation for AI agents.
  */
-export interface DataColumnForAI {
-    /** Data type */
-    type: DataColumnType;
-    /** Description */
-    description?: string;
-    /** Semantic type */
-    semantic_type?: SemanticColumnType;
-    /** Whether nullable */
-    nullable: boolean;
-    /** Whether primary key */
-    primary_key: boolean;
-    /** Whether sequence-backed auto-increment is enabled */
-    auto_increment: boolean;
-    /** Example values */
-    examples?: string[];
-}
+export type DataColumnForAI = z.infer<typeof DataColumnForAISchema>;
 
 /**
  * Simplified foreign key representation for AI agents.
  */
-export interface DataForeignKeyForAI {
-    /** Column name */
-    column: string;
-    /** Reference in "table.column" format */
-    references: string;
-}
+export type DataForeignKeyForAI = z.infer<typeof DataForeignKeyForAISchema>;
 
 /**
  * Simplified table representation for AI agents.
  */
-export interface DataTableForAI {
-    /** Description */
-    description?: string;
-    /** Semantic type */
-    semantic_type?: DataTableSemanticType;
-    /** Columns by name */
-    columns: Record<string, DataColumnForAI>;
-    /** Foreign keys */
-    foreign_keys: DataForeignKeyForAI[];
-}
+export type DataTableForAI = z.infer<typeof DataTableForAISchema>;
 
 /**
  * Simplified relationship representation for AI agents.
  */
-export interface DataRelationshipForAI {
-    /** Relationship name */
-    name: string;
-    /** Source in "table.column" format */
-    from: string;
-    /** Target in "table.column" format */
-    to: string;
-    /** Relationship type */
-    type: DataRelationshipType;
-    /** Description */
-    description?: string;
-}
+export type DataRelationshipForAI = z.infer<typeof DataRelationshipForAISchema>;
 
 /**
  * Simplified schema representation optimized for AI agent consumption.
  * Provides semantic context for understanding the data model.
  */
-export interface DataSchemaForAI {
-    schema_format: 'ai';
-    /** Store name */
-    name: string;
-    /** Schema version */
-    version: string;
-    /** Schema description */
-    description?: string;
-    /** Tables by name */
-    tables: Record<string, DataTableForAI>;
-    /** Relationships */
-    relationships: DataRelationshipForAI[];
-}
+export type DataSchemaForAI = z.infer<typeof DataSchemaForAISchema>;
 
 // ============================================================================
 // Utility Types
@@ -750,12 +446,14 @@ export const DEFAULT_RETENTION_CONFIG: DataStoreRetentionConfig = {
 /**
  * Dashboard lifecycle status.
  */
-export enum DashboardStatus {
+export const DashboardStatus = {
     /** Dashboard is active and usable */
-    ACTIVE = 'active',
+    ACTIVE: 'active',
     /** Dashboard has been archived (soft deleted) */
-    ARCHIVED = 'archived',
-}
+    ARCHIVED: 'archived',
+} as const;
+
+export type DashboardStatus = z.infer<typeof DashboardStatusSchema>;
 
 /**
  * Named SQL query that maps to a Vega data source.
@@ -764,34 +462,14 @@ export enum DashboardStatus {
  * @deprecated Use single `query` field on Dashboard instead. Multiple queries
  * prevent cross-panel interactivity. Use JOINs/CTEs in a single query.
  */
-export interface DashboardQuery {
-    /** Query name (used as data source reference in Vega specs) */
-    name: string;
-    /** SQL query (SELECT only). Can include {{param_name}} placeholders for dynamic values. */
-    sql: string;
-    /** Human-readable description */
-    description?: string;
-    /** Maximum rows to return */
-    limit?: number;
-    /** Default values for SQL parameters. Keys are parameter names (without braces). */
-    parameters?: Record<string, string>;
-}
+export type DashboardQuery = z.infer<typeof DashboardQuerySchema>;
 
 /**
  * Panel position within the dashboard grid.
  *
  * @deprecated Use combined Vega-Lite spec with vconcat/hconcat instead.
  */
-export interface DashboardPanelPosition {
-    /** Row index (0-based) */
-    row: number;
-    /** Column index (0-based) */
-    col: number;
-    /** Width in grid cells (default: 1) */
-    width?: number;
-    /** Height in grid cells (default: 1) */
-    height?: number;
-}
+export type DashboardPanelPosition = z.infer<typeof DashboardPanelPositionSchema>;
 
 /**
  * Dashboard panel with Vega/Vega-Lite visualization.
@@ -799,36 +477,14 @@ export interface DashboardPanelPosition {
  * @deprecated Use combined Vega-Lite spec with vconcat/hconcat instead.
  * Combined specs enable cross-panel interactivity (selections filtering other panels).
  */
-export interface DashboardPanel {
-    /** Panel ID (auto-generated if not provided) */
-    id?: string;
-    /** Panel title */
-    title: string;
-    /** Vega or Vega-Lite specification */
-    spec: Record<string, unknown>;
-    /** Whether spec is Vega-Lite (default: true) */
-    vegaLite?: boolean;
-    /** Query names that populate this panel's data sources */
-    dataSources: string[];
-    /** Position in the dashboard grid */
-    position: DashboardPanelPosition;
-}
+export type DashboardPanel = z.infer<typeof DashboardPanelSchema>;
 
 /**
  * Dashboard layout configuration.
  *
  * @deprecated Layout is now handled within the Vega-Lite spec via vconcat/hconcat.
  */
-export interface DashboardLayout {
-    /** Number of columns in the grid (default: 2) */
-    columns: number;
-    /** Width of each cell in pixels (default: 600) */
-    cellWidth: number;
-    /** Height of each cell in pixels (default: 400) */
-    cellHeight: number;
-    /** Padding between cells in pixels (default: 20) */
-    padding: number;
-}
+export type DashboardLayout = z.infer<typeof DashboardLayoutSchema>;
 
 /**
  * Default layout configuration for dashboards.
@@ -855,59 +511,27 @@ export interface DashboardQueryParameters {
  * Elasticsearch DSL supported by dashboard data sources.
  * Queries execute through Vertesia Store, so project/security filtering remains server-side.
  */
-export interface DashboardElasticsearchDsl {
-    query?: Record<string, unknown>;
-    aggs?: Record<string, unknown>;
-    size?: number;
-    from?: number;
-    sort?: Array<Record<string, unknown>>;
-}
+export type DashboardElasticsearchDsl = z.infer<typeof DashboardElasticsearchDslSchema>;
 
 /**
  * How an Elasticsearch DSL result should be converted into Vega rows.
  */
-export type DashboardElasticsearchResultMapping =
-    | {
-          type: 'hits';
-      }
-    | {
-          type: 'aggregation_buckets';
-          /** Dot path under `aggregations` that contains a `buckets` array. */
-          path: string;
-          /** Output field name for bucket key. Defaults to `key`. */
-          keyField?: string;
-          /** Output field name for doc count. Defaults to `doc_count`. */
-          countField?: string;
-      };
+export type DashboardElasticsearchResultMapping = z.infer<typeof DashboardElasticsearchResultMappingSchema>;
 
 /**
  * Dashboard data source backed by a Data Platform SQL query.
  */
-export interface DashboardSqlDataSource {
-    kind: 'data_sql';
-    /** SQL query that returns all rows for the dashboard. */
-    query: string;
-    /** Maximum rows to return from the query. */
-    queryLimit?: number;
-    /** Default values for SQL {{param}} placeholders. */
-    queryParameters?: Record<string, string>;
-}
+export type DashboardSqlDataSource = z.infer<typeof DashboardSqlDataSourceSchema>;
 
 /**
  * Dashboard data source backed by Vertesia Store Elasticsearch DSL.
  */
-export interface DashboardStoreElasticsearchDataSource {
-    kind: 'store_es_dsl';
-    /** Elasticsearch DSL query executed through the secured Store query API. */
-    dsl: DashboardElasticsearchDsl;
-    /** Result mapping. Defaults to `hits`. */
-    result?: DashboardElasticsearchResultMapping;
-}
+export type DashboardStoreElasticsearchDataSource = z.infer<typeof DashboardStoreElasticsearchDataSourceSchema>;
 
 /**
  * Data source for a Vega dashboard.
  */
-export type DashboardDataSource = DashboardSqlDataSource | DashboardStoreElasticsearchDataSource;
+export type DashboardDataSource = z.infer<typeof DashboardDataSourceSchema>;
 
 /**
  * Dashboard definition contributed by an app package.
@@ -915,58 +539,12 @@ export type DashboardDataSource = DashboardSqlDataSource | DashboardStoreElastic
  * App dashboard IDs are local to the app. The platform exposes them as
  * `app:<app_name>:<id>` when listing or retrieving dashboards.
  */
-export interface AppDashboardDefinition {
-    /** Local app dashboard ID. */
-    id: string;
-    /** Machine-friendly dashboard name. Defaults to `id`. */
-    name?: string;
-    /** Display title. Defaults to `name` or `id`. */
-    title?: string;
-    /** User-facing description. */
-    description?: string;
-    /** Tags for discovery and filtering. */
-    tags?: string[];
-    /** Data source used to populate Vega `data.values`. */
-    dataSource?: DashboardDataSource;
-    /** SQL query shortcut for app dashboards backed by data stores. */
-    query?: string;
-    /** Maximum SQL rows to return. */
-    queryLimit?: number;
-    /** Default values for SQL {{param}} placeholders. */
-    queryParameters?: Record<string, string>;
-    /** Complete Vega-Lite specification for the dashboard. */
-    spec?: Record<string, unknown>;
-    /** Legacy named SQL queries. */
-    queries?: DashboardQuery[];
-    /** Legacy panel definitions. */
-    panels?: DashboardPanel[];
-    /** Legacy dashboard layout. */
-    layout?: DashboardLayout;
-}
+export type AppDashboardDefinition = z.infer<typeof AppDashboardDefinitionSchema>;
 
 /**
  * Summary view of a dashboard (for listings).
  */
-export interface DashboardItem extends BaseObject {
-    /** Parent data store ID */
-    store_id: string;
-    /** Current status */
-    status: DashboardStatus;
-    /** Number of panels (deprecated, kept for backwards compat) */
-    panel_count: number;
-    /** Number of queries (deprecated, kept for backwards compat) */
-    query_count: number;
-    /** Last render timestamp */
-    last_rendered_at?: string;
-    /** Tags for organization */
-    tags: string[];
-    /** Source of the dashboard definition. Defaults to stored dashboards. */
-    source?: 'stored' | 'app';
-    /** App name when `source` is `app`. */
-    app_name?: string;
-    /** App dashboards are read-only until cloned into a stored dashboard. */
-    readonly?: boolean;
-}
+export type DashboardItem = z.infer<typeof DashboardItemSchema>;
 
 /**
  * Full dashboard with SQL query and Vega-Lite specification.
@@ -983,101 +561,18 @@ export interface DashboardItem extends BaseObject {
  * - `layout` for grid positioning
  * - No cross-panel interactivity
  */
-export interface Dashboard extends DashboardItem {
-    // ============= New architecture (v2) =============
-    /**
-     * Data source used to populate Vega `data.values`.
-     * When omitted, top-level `query` is treated as a SQL data source for backwards compatibility.
-     */
-    dataSource?: DashboardDataSource;
-    /**
-     * SQL query that returns all data for the dashboard.
-     * Use JOINs, CTEs, or UNION ALL to combine data from multiple tables.
-     * Can include {{param_name}} placeholders for dynamic values.
-     * @deprecated Use `dataSource: { kind: 'data_sql', query }` instead.
-     */
-    query?: string;
-    /**
-     * Maximum rows to return from the query (default: 10000).
-     * @deprecated Use `dataSource.queryLimit` instead.
-     */
-    queryLimit?: number;
-    /**
-     * Default values for SQL parameters.
-     * @deprecated Use `dataSource.queryParameters` instead.
-     */
-    queryParameters?: Record<string, string>;
-    /**
-     * Complete Vega-Lite specification for the entire dashboard.
-     * Use vconcat/hconcat for multiple panels, params for interactivity.
-     * Data is injected at runtime from query results.
-     */
-    spec?: Record<string, unknown>;
-
-    // ============= Legacy architecture (v1, deprecated) =============
-    /**
-     * @deprecated Use single `query` field instead.
-     * Named SQL queries (kept for backwards compatibility).
-     */
-    queries: DashboardQuery[];
-    /**
-     * @deprecated Use single `spec` field with vconcat/hconcat instead.
-     * Panel definitions (kept for backwards compatibility).
-     */
-    panels: DashboardPanel[];
-    /**
-     * @deprecated Layout is now handled within the Vega-Lite spec.
-     * Layout configuration (kept for backwards compatibility).
-     */
-    layout: DashboardLayout;
-
-    // ============= Common fields =============
-    /** URL of last rendered image */
-    last_render_url?: string;
-}
+export type Dashboard = z.infer<typeof DashboardSchema>;
 
 /**
  * Payload for creating a new dashboard.
  * Requires a data source and spec (Vega-Lite).
  */
-export interface CreateDashboardPayload {
-    /** Dashboard name (unique within store) */
-    name: string;
-    /** Dashboard summary */
-    summary?: string;
-    /** Data source used to populate Vega `data.values`. */
-    dataSource?: DashboardDataSource;
-    /** SQL query that returns all data for the dashboard. Deprecated shortcut for a SQL data source. */
-    query?: string;
-    /** Maximum rows to return from the query (default: 10000) */
-    queryLimit?: number;
-    /** Default values for SQL {{param}} placeholders */
-    queryParameters?: Record<string, string>;
-    /** Complete Vega-Lite specification (use vconcat/hconcat for multiple panels) */
-    spec: Record<string, unknown>;
-}
+export type CreateDashboardPayload = z.infer<typeof CreateDashboardPayloadSchema>;
 
 /**
  * Payload for updating a dashboard.
  */
-export interface UpdateDashboardPayload {
-    /** Dashboard name */
-    name?: string;
-    /** Dashboard summary */
-    summary?: string;
-    /** Data source used to populate Vega `data.values`. */
-    dataSource?: DashboardDataSource;
-    /** SQL query that returns all data for the dashboard. Deprecated shortcut for a SQL data source. */
-    query?: string;
-    /** Maximum rows to return from the query (default: 10000) */
-    queryLimit?: number;
-    /** Default values for SQL {{param}} placeholders */
-    queryParameters?: Record<string, string>;
-    /** Complete Vega-Lite specification (use vconcat/hconcat for multiple panels) */
-    spec?: Record<string, unknown>;
-    /** Skip auto-version creation */
-    skip_versioning?: boolean;
-}
+export type UpdateDashboardPayload = z.infer<typeof UpdateDashboardPayloadSchema>;
 
 /**
  * Payload for previewing a dashboard (render without saving).
@@ -1140,85 +635,19 @@ export interface RenderDashboardResult {
  * A point-in-time version of a dashboard.
  * Stores full snapshot inline (no external storage needed for small JSON documents).
  */
-export interface DashboardVersion {
-    /** Version ID */
-    id: string;
-    /** Parent dashboard ID */
-    dashboard_id: string;
-    /** Version number (auto-incremented) */
-    version_number: number;
-    /** Commit message describing the change */
-    message: string;
-    /** Snapshot of v2 data source at this version */
-    dataSource?: DashboardDataSource;
-    /** Snapshot of v2 SQL query at this version */
-    query?: string;
-    /** Snapshot of v2 query limit at this version */
-    queryLimit?: number;
-    /** Snapshot of v2 query parameters at this version */
-    queryParameters?: Record<string, string>;
-    /** Snapshot of v2 Vega-Lite spec at this version */
-    spec?: Record<string, unknown>;
-    /** Snapshot of queries at this version */
-    queries: DashboardQuery[];
-    /** Snapshot of panels at this version */
-    panels: DashboardPanel[];
-    /** Snapshot of layout at this version */
-    layout: DashboardLayout;
-    /** Whether this is the currently active/displayed version */
-    is_current: boolean;
-    /** Whether this is a named snapshot (protected from TTL cleanup) */
-    is_snapshot: boolean;
-    /** Snapshot name (if is_snapshot) */
-    snapshot_name?: string;
-    /** Creation timestamp */
-    created_at: string;
-    /** User/agent who created this version */
-    created_by?: string;
-}
+export type DashboardVersion = z.infer<typeof DashboardVersionSchema>;
 
 /**
  * Summary view of a dashboard version (for listings).
  */
-export interface DashboardVersionItem {
-    /** Version ID */
-    id: string;
-    /** Parent dashboard ID */
-    dashboard_id: string;
-    /** Version number */
-    version_number: number;
-    /** Commit message */
-    message: string;
-    /** Whether this is the current version */
-    is_current: boolean;
-    /** Whether this is a named snapshot */
-    is_snapshot: boolean;
-    /** Snapshot name (if is_snapshot) */
-    snapshot_name?: string;
-    /** Number of panels in this version */
-    panel_count: number;
-    /** Number of queries in this version */
-    query_count: number;
-    /** Creation timestamp */
-    created_at: string;
-    /** User/agent who created */
-    created_by?: string;
-}
+export type DashboardVersionItem = z.infer<typeof DashboardVersionItemSchema>;
 
 /**
  * Payload for creating a named snapshot.
  */
-export interface CreateDashboardSnapshotPayload {
-    /** Snapshot name (must be unique within dashboard) */
-    name: string;
-    /** Snapshot description/message */
-    message: string;
-}
+export type CreateDashboardSnapshotPayload = z.infer<typeof CreateDashboardSnapshotPayloadSchema>;
 
 /**
  * Payload for promoting a version to current.
  */
-export interface PromoteDashboardVersionPayload {
-    /** Commit message for the promotion */
-    message?: string;
-}
+export type PromoteDashboardVersionPayload = z.infer<typeof PromoteDashboardVersionPayloadSchema>;