@oxy-hq/sdk 1.0.0 → 2.0.0

package/dist/index.d.cts

@@ -1,967 +1,534 @@
 
-import * as duckdb from "@duckdb/duckdb-wasm";
-import React, { ReactNode } from "react";
+import * as React from "react";
 
-//#region src/config.d.ts
-/**
- * Configuration for the Oxy SDK
- */
-interface OxyConfig {
+//#region src/customer-app/manifest.d.ts
+/** Wire shape of `oxy-app.json` (v2 only). */
+interface OxyAppManifest {
+  /** Must be 2. v1 manifests are no longer supported. */
+  schemaVersion: 2;
   /**
-   * Base URL of the Oxy API (e.g., 'https://api.oxy.tech' or 'http://localhost:3000')
+   * Optional display name. The admin "Link existing" dialog prefills
+   * its Name field from this. Omit to let oxy fall back to the
+   * folder basename.
    */
-  baseUrl: string;
+  name?: string;
   /**
-   * API key for authentication (optional for local development)
+   * URL slug. **Required.** The canonical source of truth — the
+   * dialog locks the slug field to this value, and
+   * `OXY_APP_BASE_PATH=/customer-apps/<org>/<slug>/` baked into the
+   * build must match.
    */
-  apiKey?: string;
+  slug: string;
   /**
-   * Project ID (UUID)
+   * Optional org slug. Prefills the dialog's org picker; operator
+   * can still override. Carries no security weight — the actual
+   * access check is on the linked row.
    */
-  projectId: string;
+  orgSlug?: string;
   /**
-   * Optional branch name (defaults to current branch if not specified)
+   * Optional project (workspace) uuid the bundle expects to read
+   * from. Used by `useQuery` to construct the
+   * `/api/projects/:id/query` URL.
    */
-  branch?: string;
+  projectId?: string;
+}
+/**
+ * Manifest + runtime-injected identity needed to call oxy. Callers
+ * should treat this as the only source of truth for "which org/app
+ * does this bundle belong to."
+ */
+interface ResolvedCustomerAppManifest {
+  manifest: OxyAppManifest;
   /**
-   * Request timeout in milliseconds (default: 30000)
+   * Always an empty array for v2 manifests. Kept for API compatibility;
+   * callers that previously iterated product names should switch to
+   * explicit `useQuery` calls.
+   * @deprecated Will be removed in a future version.
    */
-  timeout?: number;
+  productNames: string[];
+  /** Org slug injected by oxy. */
+  orgSlug: string;
+  /** App slug injected by oxy. */
+  appSlug: string;
   /**
-   * Parent window origin for postMessage authentication (iframe scenarios)
-   * Required when using postMessage auth for security.
-   * Example: 'https://app.example.com'
-   * Use '*' only in development!
+   * The oxy server's API base URL. Empty string when oxy serves the
+   * bundle itself (same-origin, the common case); a full URL only
+   * when the bundle is running under a dev server proxy.
    */
-  parentOrigin?: string;
+  apiBaseUrl: string;
+  /** App UUID; informational. */
+  appId?: string;
   /**
-   * Disable automatic postMessage authentication even if in iframe
-   * Set to true if you want to provide API key manually in iframe context
+   * Project (workspace) UUID. Injection (`window.__OXY_APP__.projectId`)
+   * wins over the manifest's `projectId` field — the admin row is
+   * authoritative. Manifest `projectId` is a dev-time hint used only
+   * when running without a server. Used by `useQuery` to construct the
+   * `/api/projects/:id/query` URL.
    */
-  disableAutoAuth?: boolean;
-}
-/**
- * Creates an Oxy configuration from environment variables
- *
- * Environment variables:
- * - OXY_URL: Base URL of the Oxy API
- * - OXY_API_KEY: API key for authentication
- * - OXY_PROJECT_ID: Project ID (UUID)
- * - OXY_BRANCH: (Optional) Branch name
- *
- * @param overrides - Optional configuration overrides
- * @returns OxyConfig object
- * @throws Error if required environment variables are missing
- */
-declare function createConfig(overrides?: Partial<OxyConfig>): OxyConfig;
-/**
- * Creates an Oxy configuration asynchronously with support for postMessage authentication
- *
- * This is the recommended method for iframe scenarios where authentication
- * needs to be obtained from the parent window via postMessage.
- *
- * When running in an iframe without an API key, this function will:
- * 1. Detect the iframe context
- * 2. Send an authentication request to the parent window
- * 3. Wait for the parent to respond with credentials
- * 4. Return the configured client
- *
- * Environment variables (fallback):
- * - OXY_URL: Base URL of the Oxy API
- * - OXY_API_KEY: API key for authentication
- * - OXY_PROJECT_ID: Project ID (UUID)
- * - OXY_BRANCH: (Optional) Branch name
- *
- * @param overrides - Optional configuration overrides
- * @returns Promise resolving to OxyConfig object
- * @throws Error if required configuration is missing
- * @throws PostMessageAuthTimeoutError if parent doesn't respond
- *
- * @example
- * ```typescript
- * // Automatic iframe detection and authentication
- * const config = await createConfigAsync({
- *   parentOrigin: 'https://app.example.com',
- *   projectId: 'my-project-id',
- *   baseUrl: 'https://api.oxy.tech'
- * });
- * ```
- */
-declare function createConfigAsync(overrides?: Partial<OxyConfig>): Promise<OxyConfig>;
-//#endregion
-//#region src/types.d.ts
-/**
- * Represents an app item in the project
- */
-interface AppItem {
-  name: string;
-  path: string;
-}
-/**
- * Reference to a data file (usually parquet)
- */
-interface FileReference {
-  file_path: string;
-}
-/**
- * Table data structure for in-memory tables
- * (used when data is fetched and parsed)
- */
-interface TableData {
-  columns: string[];
-  rows: unknown[][];
-  total_rows?: number;
-}
-type DataContainer = Record<string, FileReference>;
-/**
- * Response from app data endpoints
- */
-interface AppDataResponse {
-  data: DataContainer | null;
-  error: string | null;
-}
-/**
- * Display with potential error
- */
-interface DisplayWithError {
-  display?: DisplayData;
-  error?: string;
-}
-/**
- * Display data structure
- */
-interface DisplayData {
-  type: string;
-  content: unknown;
-}
-/**
- * Response from get displays endpoint
- */
-interface GetDisplaysResponse {
-  displays: DisplayWithError[];
-}
-/**
- * PostMessage authentication protocol types
- */
-/**
- * Request message sent from iframe to parent window
- */
-interface OxyAuthRequestMessage {
-  type: "OXY_AUTH_REQUEST";
-  version: "1.0";
-  timestamp: number;
-  requestId: string;
-}
-/**
- * Response message sent from parent window to iframe
- */
-interface OxyAuthResponseMessage {
-  type: "OXY_AUTH_RESPONSE";
-  version: "1.0";
-  requestId: string;
-  apiKey?: string;
   projectId?: string;
-  baseUrl?: string;
 }
-/**
- * Options for postMessage authentication
- */
-interface PostMessageAuthOptions {
-  /** Required parent window origin for security (e.g., 'https://app.example.com'). Use '*' only in development! */
-  parentOrigin?: string;
-  /** Timeout in milliseconds (default: 5000) */
-  timeout?: number;
-  /** Number of retry attempts (default: 0) */
-  retries?: number;
+interface LoadManifestOptions {
+  /**
+   * Override the URL the manifest is fetched from. Default:
+   * `<injected_base>/oxy-app.json` or `/oxy-app.json`.
+   * Useful for non-Next bundlers — set explicitly to wherever your
+   * bundler emits static assets.
+   */
+  manifestUrl?: string;
 }
 /**
- * Result from successful postMessage authentication
+ * Load + validate the manifest. Cached after the first call so callers
+ * can invoke this from every component without coordinating.
  */
-interface PostMessageAuthResult {
-  apiKey?: string;
-  projectId?: string;
-  baseUrl?: string;
-  source: "postmessage";
+declare function loadCustomerAppManifest(options?: LoadManifestOptions): Promise<ResolvedCustomerAppManifest>;
+/** For tests: reset the cache between runs. */
+declare function _resetCustomerAppManifestCacheForTest(): void;
+//#endregion
+//#region src/customer-app/debug.d.ts
+/** Untyped at the boundary — keep it loose so server-side schema
+ * additions don't break older bundles. Stable enough for inspection
+ * but not a contract clients should depend on field-by-field. */
+interface CustomerAppDebugSnapshot {
+  org_slug: string;
+  app_slug: string;
+  app: {
+    id: string;
+    slug: string;
+    name: string;
+    status: string;
+    source_type: string;
+    project_id: string;
+    branch: string;
+  };
+  bundle_dir: string | null;
+  bundle_dir_exists: boolean;
+  /** Raw parsed manifest from the server — kept loose so schema additions don't break older bundles. */
+  manifest: Record<string, unknown> | null;
+  manifest_error: string | null;
+  products: Array<{
+    name: string;
+    producer: string;
+  }>;
 }
 /**
- * Custom error classes for postMessage authentication
- */
-/**
- * Error thrown when postMessage authentication times out
+ * Fetch the server-side diagnostic snapshot for this bundle. Pair with
+ * `loadCustomerAppManifest()` — pass its result here. Logs the
+ * snapshot through the SDK logger so it appears in the bundle's
+ * console at info level.
  */
-declare class PostMessageAuthTimeoutError extends Error {
-  constructor(timeout: number);
+declare function getCustomerAppDebug(resolved: ResolvedCustomerAppManifest): Promise<CustomerAppDebugSnapshot>;
+//#endregion
+//#region src/customer-app/errors.d.ts
+interface CustomerAppErrorReport {
+  title: string;
+  message: string;
+  hint: string;
+  docs?: string;
 }
+/** Interpret a thrown error as a structured report for UI display. */
+declare function interpretCustomerAppError(err: unknown): CustomerAppErrorReport;
+//#endregion
+//#region src/customer-app/inject.d.ts
 /**
- * Error thrown when authentication response comes from unauthorized origin
+ * Shape of `window.__OXY_APP__` written by oxy at serve time.
+ * Consumed by `loadCustomerAppManifest` as the authoritative identity
+ * source (overrides any hints in `oxy-app.json`).
  */
-declare class PostMessageAuthInvalidOriginError extends Error {
-  constructor(expected: string, actual: string);
+interface OxyInjectedAppConfig {
+  appId: string;
+  slug: string;
+  orgId: string;
+  orgSlug: string;
+  projectId: string;
+  branch: string;
+  /** Empty string means same-origin (the default for v2). */
+  apiBaseUrl: string;
 }
-/**
- * Error thrown when postMessage authentication is attempted outside iframe context
- */
-declare class PostMessageAuthNotInIframeError extends Error {
-  constructor();
+declare global {
+  interface Window {
+    __OXY_APP__?: OxyInjectedAppConfig;
+  }
 }
 /**
- * Error thrown when authentication response is malformed or invalid
+ * Read the runtime app-config oxy injected at serve time. Returns
+ * `undefined` outside the browser or when the global isn't set
+ * (`pnpm dev` against a non-oxy server, etc. — manifest hints are
+ * the fallback).
  */
-declare class PostMessageAuthInvalidResponseError extends Error {
-  constructor(reason: string);
+declare function readInjectedAppConfig(): OxyInjectedAppConfig | undefined;
+//#endregion
+//#region src/customer-app/logger.d.ts
+type OxyAppLogLevel = "debug" | "info" | "warn" | "error";
+interface OxyAppLogger {
+  log(level: OxyAppLogLevel, msg: string, ctx?: Record<string, unknown>): void;
 }
+/** Replace the global logger. Pass `null` to silence everything. */
+declare function setOxyAppLogger(logger: OxyAppLogger | null): void;
+/** Used by the SDK internals; not part of the public surface. */
+declare function getOxyAppLogger(): OxyAppLogger;
 //#endregion
-//#region src/client.d.ts
+//#region src/customer-app/react.d.ts
 /**
- * Oxy API Client for interacting with Oxy data
+ * Credentialed fetch wrapper stored in context so `useQuery` can share
+ * the same request mechanism without coupling it to the global `fetch`.
+ *
+ * Sends `credentials: "include"` so the session cookie rides along when
+ * the app is served by oxy (in-workspace / admin preview) — that cookie
+ * authorizes data calls. For local dev (cross-origin), the
+ * `@oxy-hq/vite-plugin` proxy attaches the developer's token. Bundles may
+ * override the fetcher for test/proxy environments.
  */
-declare class OxyClient {
-  private config;
-  constructor(config: OxyConfig);
+type AppFetcher = typeof fetch;
+interface OxyAppProviderProps {
+  /** Optional manifest load options. Same shape as `loadCustomerAppManifest`. */
+  manifestOptions?: LoadManifestOptions;
   /**
-   * Creates an OxyClient instance asynchronously with support for postMessage authentication
-   *
-   * This is the recommended method when using the SDK in an iframe that needs to
-   * obtain authentication from the parent window via postMessage.
-   *
-   * @param config - Optional configuration overrides
-   * @returns Promise resolving to OxyClient instance
-   * @throws Error if required configuration is missing
-   * @throws PostMessageAuthTimeoutError if parent doesn't respond
-   *
-   * @example
-   * ```typescript
-   * // In an iframe - automatic postMessage auth
-   * const client = await OxyClient.create({
-   *   parentOrigin: 'https://app.example.com',
-   *   projectId: 'my-project-id',
-   *   baseUrl: 'https://api.oxy.tech'
-   * });
-   *
-   * // Use the client normally
-   * const apps = await client.listApps();
-   * ```
-   */
-  static create(config?: Partial<OxyConfig>): Promise<OxyClient>;
-  /**
-   * Encodes a file path to base64 for use in API URLs.
-   * Handles Unicode characters (e.g., emojis) properly in both Node.js and browser.
-   */
-  private encodePathBase64;
-  /**
-   * Makes an authenticated HTTP request to the Oxy API
-   */
-  private request;
-  /**
-   * Builds query parameters including optional branch
-   */
-  private buildQueryParams;
-  /**
-   * Lists all apps in the project
-   *
-   * @returns Array of app items
-   *
-   * @example
-   * ```typescript
-   * const apps = await client.listApps();
-   * console.log('Available apps:', apps);
-   * ```
-   */
-  listApps(): Promise<AppItem[]>;
-  /**
-   * Gets data for a specific app
-   *
-   * @param appPath - Relative path to the app file (e.g., 'my-app.app.yml')
-   * @returns App data response
-   *
-   * @example
-   * ```typescript
-   * const data = await client.getAppData('dashboard.app.yml');
-   * if (data.error) {
-   *   console.error('Error:', data.error);
-   * } else {
-   *   console.log('App data:', data.data);
-   * }
-   * ```
-   */
-  getAppData(appPath: string): Promise<AppDataResponse>;
-  /**
-   * Runs an app and returns fresh data (bypasses cache)
-   *
-   * @param appPath - Relative path to the app file
-   * @returns App data response
-   *
-   * @example
-   * ```typescript
-   * const data = await client.runApp('dashboard.app.yml');
-   * console.log('Fresh app data:', data.data);
-   * ```
+   * Rendered while the manifest is loading. Defaults to nothing; pass a
+   * spinner if you want one.
    */
-  runApp(appPath: string): Promise<AppDataResponse>;
+  fallback?: React.ReactNode;
   /**
-   * Gets display configurations for an app
-   *
-   * @param appPath - Relative path to the app file
-   * @returns Display configurations with potential errors
-   *
-   * @example
-   * ```typescript
-   * const displays = await client.getDisplays('dashboard.app.yml');
-   * displays.displays.forEach(d => {
-   *   if (d.error) {
-   *     console.error('Display error:', d.error);
-   *   } else {
-   *     console.log('Display:', d.display);
-   *   }
-   * });
-   * ```
-   */
-  getDisplays(appPath: string): Promise<GetDisplaysResponse>;
-  /**
-   * Gets a file from the app state directory (e.g., generated charts, images)
-   *
-   * This is useful for retrieving generated assets like charts, images, or other
-   * files produced by app workflows and stored in the state directory.
-   *
-   * @param filePath - Relative path to the file in state directory
-   * @returns Blob containing the file data
-   *
-   * @example
-   * ```typescript
-   * // Get a generated chart image
-   * const blob = await client.getFile('charts/sales-chart.png');
-   * const imageUrl = URL.createObjectURL(blob);
-   *
-   * // Use in an img tag
-   * document.querySelector('img').src = imageUrl;
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Download a file
-   * const blob = await client.getFile('exports/data.csv');
-   * const a = document.createElement('a');
-   * a.href = URL.createObjectURL(blob);
-   * a.download = 'data.csv';
-   * a.click();
-   * ```
-   */
-  getFile(filePath: string): Promise<Blob>;
-  /**
-   * Gets a file URL for direct browser access
-   *
-   * This returns a URL that can be used directly in img tags, fetch calls, etc.
-   * The URL includes authentication via query parameters.
-   *
-   * @param filePath - Relative path to the file in state directory
-   * @returns Full URL to the file
-   *
-   * @example
-   * ```typescript
-   * const imageUrl = client.getFileUrl('charts/sales-chart.png');
-   *
-   * // Use directly in img tag (in environments where query-based auth is supported)
-   * document.querySelector('img').src = imageUrl;
-   * ```
+   * Rendered on manifest load failure. Receives the structured error
+   * report so the bundle can show its own branded error card. Defaults
+   * to a minimal text-only fallback (better than a blank page).
    */
-  getFileUrl(filePath: string): string;
+  errorFallback?: (err: CustomerAppErrorReport) => React.ReactNode;
   /**
-   * Fetches a parquet file and parses it into table data
-   *
-   * @param filePath - Relative path to the parquet file
-   * @param limit - Maximum number of rows to return (default: 100)
-   * @returns TableData with columns and rows
-   *
-   * @example
-   * ```typescript
-   * const tableData = await client.getTableData('data/sales.parquet', 50);
-   * console.log(tableData.columns);
-   * console.log(tableData.rows);
-   * console.log(`Total rows: ${tableData.total_rows}`);
-   * ```
+   * Override the fetch implementation used by all hooks (`useQuery`).
+   * Useful for test environments or proxy setups. Defaults to a wrapper
+   * that sets `credentials: "include"` on every request.
    */
-  getTableData(filePath: string, limit?: number): Promise<TableData>;
+  fetcher?: AppFetcher;
+  children: React.ReactNode;
 }
-//#endregion
-//#region src/parquet.d.ts
 /**
- * Initialize DuckDB-WASM instance
- */
-declare function initializeDuckDB(): Promise<duckdb.AsyncDuckDB>;
+ * Top-level provider. Loads the manifest once on mount; children only
+ * render after the manifest is ready (or the error fallback fires).
+ */
+declare function OxyAppProvider(props: OxyAppProviderProps): React.JSX.Element;
+/**
+ * Error thrown by all customer-app hooks when an API call returns a
+ * non-2xx response. Carries the structured `code` + `hint` the server
+ * emits so bundle UIs can render an actionable message instead of
+ * "404: { ...json... }".
+ *
+ * The server contract is documented in
+ * `crates/app/src/server/api/projects/agent_ask.rs` and
+ * `procedure_run.rs` — both emit `{ message, code?, hint? }` as JSON.
+ * Hooks that previously wrapped the raw text in `new Error()` now
+ * throw this type instead.
+ */
+declare class OxyApiError extends Error {
+  readonly status: number;
+  readonly code: string | null;
+  readonly hint: string | null;
+  constructor(opts: {
+    status: number;
+    message: string;
+    code?: string | null;
+    hint?: string | null;
+  });
+}
 /**
- * Query result interface
+ * Read the resolved manifest from context. Throws if called outside
+ * `<OxyAppProvider>` — that's a programmer error worth surfacing
+ * loudly, not silently swallowing.
  */
-interface QueryResult {
+declare function useResolvedManifest(): ResolvedCustomerAppManifest;
+interface UseQueryInput {
+  sql: string;
+  database?: string;
+}
+interface UseQueryOpts {
+  params?: Record<string, string | number | boolean | null | undefined>;
+  /** Set false to skip the request (e.g., waiting on user input). */
+  enabled?: boolean;
+}
+interface UseQueryResult<Row = Record<string, unknown>> {
+  rows: Row[];
   columns: string[];
-  rows: unknown[][];
-  rowCount: number;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
 }
 /**
- * ParquetReader provides methods to read and query Parquet files.
- * Supports registering multiple Parquet files with different table names.
- */
-declare class ParquetReader {
-  private tableMap;
-  constructor();
-  /**
-   * Generate a unique internal table name to prevent conflicts
-   */
-  private generateInternalTableName;
-  /**
-   * Register a Parquet file from a Blob with a specific table name
-   *
-   * @param blob - Parquet file as Blob
-   * @param tableName - Name to use for the table in queries (required)
-   *
-   * @example
-   * ```typescript
-   * const blob = await client.getFile('data/sales.parquet');
-   * const reader = new ParquetReader();
-   * await reader.registerParquet(blob, 'sales');
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Register multiple files
-   * const reader = new ParquetReader();
-   * await reader.registerParquet(salesBlob, 'sales');
-   * await reader.registerParquet(customersBlob, 'customers');
-   * const result = await reader.query('SELECT * FROM sales JOIN customers ON sales.customer_id = customers.id');
-   * ```
-   */
-  registerParquet(blob: Blob, tableName: string): Promise<void>;
-  /**
-   * Register multiple Parquet files at once
-   *
-   * @param files - Array of objects containing blob and tableName
-   *
-   * @example
-   * ```typescript
-   * const reader = new ParquetReader();
-   * await reader.registerMultipleParquet([
-   *   { blob: salesBlob, tableName: 'sales' },
-   *   { blob: customersBlob, tableName: 'customers' },
-   *   { blob: productsBlob, tableName: 'products' }
-   * ]);
-   * const result = await reader.query('SELECT * FROM sales JOIN customers ON sales.customer_id = customers.id');
-   * ```
-   */
-  registerMultipleParquet(files: Array<{
-    blob: Blob;
-    tableName: string;
-  }>): Promise<void>;
-  /**
-   * Execute a SQL query against the registered Parquet data
-   *
-   * @param sql - SQL query string
-   * @returns Query result with columns and rows
-   *
-   * @example
-   * ```typescript
-   * const result = await reader.query('SELECT * FROM sales LIMIT 10');
-   * console.log(result.columns);
-   * console.log(result.rows);
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Query multiple tables
-   * await reader.registerParquet(salesBlob, 'sales');
-   * await reader.registerParquet(customersBlob, 'customers');
-   * const result = await reader.query(`
-   *   SELECT s.*, c.name
-   *   FROM sales s
-   *   JOIN customers c ON s.customer_id = c.id
-   * `);
-   * ```
-   */
-  query(sql: string): Promise<QueryResult>;
-  /**
-   * Get all data from a registered table
-   *
-   * @param tableName - Name of the table to query
-   * @param limit - Maximum number of rows to return (default: all)
-   * @returns Query result
-   *
-   * @example
-   * ```typescript
-   * const allData = await reader.getAll('sales');
-   * const first100 = await reader.getAll('sales', 100);
-   * ```
-   */
-  getAll(tableName: string, limit?: number): Promise<QueryResult>;
-  /**
-   * Get table schema information
-   *
-   * @param tableName - Name of the table to describe
-   * @returns Schema information
-   *
-   * @example
-   * ```typescript
-   * const schema = await reader.getSchema('sales');
-   * console.log(schema.columns); // ['id', 'name', 'sales']
-   * console.log(schema.rows);    // [['id', 'INTEGER'], ['name', 'VARCHAR'], ...]
-   * ```
-   */
-  getSchema(tableName: string): Promise<QueryResult>;
-  /**
-   * Get row count for a table
-   *
-   * @param tableName - Name of the table to count
-   * @returns Number of rows in the table
-   *
-   * @example
-   * ```typescript
-   * const count = await reader.count('sales');
-   * console.log(`Total rows: ${count}`);
-   * ```
-   */
-  count(tableName: string): Promise<number>;
+ * Execute an ad-hoc SQL query against the project linked to this
+ * customer app. The query is specified inline by the caller; no
+ * manifest declaration is involved.
+ *
+ * Re-runs whenever `input` or enabled `params` change. Use the
+ * `enabled` option to defer the first fetch until required data is
+ * available (e.g. a user-supplied filter value).
+ */
+declare function useQuery<Row = Record<string, unknown>>(input: UseQueryInput, opts?: UseQueryOpts): UseQueryResult<Row>;
+/** Scalar filter operators (compared against a single value). */
+type SemanticScalarOp = "eq" | "neq" | "lt" | "lte" | "gt" | "gte";
+/** Array filter operators (compared against a list). */
+type SemanticArrayOp = "in" | "not_in";
+/** Date-range filter operators. `from` / `to` accept ISO date strings. */
+type SemanticDateRangeOp = "in_date_range" | "not_in_date_range";
+/**
+ * One filter clause. The `field` references a dimension name within
+ * the topic; the `op` discriminator picks which other fields are
+ * meaningful. Wire shape matches `agentic_semantic::SemanticFilter`
+ * verbatim — the bundle's request body is forwarded to airlayer's
+ * compiler with no translation.
+ */
+type SemanticFilter = {
+  field: string;
+  op: SemanticScalarOp;
+  value: string | number | boolean | null;
+} | {
+  field: string;
+  op: SemanticArrayOp;
+  values: Array<string | number | boolean | null>;
+} | {
+  field: string;
+  op: SemanticDateRangeOp;
+  from: string;
+  to: string;
+};
+/** Time dimensions with optional granularity (e.g. "day", "month"). */
+interface SemanticTimeDimension {
+  dimension: string;
+  granularity?: "day" | "week" | "month" | "quarter" | "year";
+}
+interface UseSemanticQueryInput {
+  topic: string;
+  dimensions?: string[];
+  measures?: string[];
+  time_dimensions?: SemanticTimeDimension[];
+  filters?: SemanticFilter[];
+  limit?: number;
+}
+interface UseSemanticQueryOpts {
+  /** Set false to skip the request (e.g., waiting on user input). */
+  enabled?: boolean;
   /**
-   * Close and cleanup all registered resources
+   * When true, the response includes the compiled SQL string at
+   * `sql`. Off by default — production callers shouldn't bake the
+   * warehouse SQL into their UI. Bundle authors flip this on while
+   * debugging.
    */
-  close(): Promise<void>;
+  debug?: boolean;
+}
+interface UseSemanticQueryResult<Row = Record<string, unknown>> {
+  rows: Row[];
+  columns: string[];
+  /** True when the result was capped at the server's row limit. */
+  truncated: boolean;
+  /** Compiled SQL — populated only when `opts.debug` is true. */
+  sql: string | null;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
 }
 /**
- * Helper function to quickly read a Parquet blob and execute a query
- *
- * @param blob - Parquet file as Blob
- * @param tableName - Name to use for the table in queries (default: 'data')
- * @param sql - SQL query to execute (optional, defaults to SELECT * FROM tableName)
- * @returns Query result
- *
- * @example
- * ```typescript
- * const blob = await client.getFile('data/sales.parquet');
- * const result = await queryParquet(blob, 'sales', 'SELECT product, SUM(amount) as total FROM sales GROUP BY product');
- * console.log(result);
- * ```
- */
-declare function queryParquet(blob: Blob, tableName?: string, sql?: string): Promise<QueryResult>;
-/**
- * Helper function to read Parquet file and get all data
- *
- * @param blob - Parquet file as Blob
- * @param tableName - Name to use for the table (default: 'data')
- * @param limit - Maximum number of rows (optional)
- * @returns Query result
- *
- * @example
- * ```typescript
- * const blob = await client.getFile('data/sales.parquet');
- * const data = await readParquet(blob, 'sales', 1000);
- * console.log(`Loaded ${data.rowCount} rows`);
- * ```
- */
-declare function readParquet(blob: Blob, tableName?: string, limit?: number): Promise<QueryResult>;
-//#endregion
-//#region src/sdk.d.ts
-/**
- * OxySDK provides a unified interface for fetching data from Oxy and querying it with SQL.
- * It combines OxyClient (for API calls) and ParquetReader (for SQL queries) into a single,
- * easy-to-use interface.
- *
- * @example
- * ```typescript
- * // Create SDK instance
- * const sdk = new OxySDK({ apiKey: 'your-key', projectId: 'your-project' });
- *
- * // Load a parquet file and query it
- * await sdk.loadFile('data/sales.parquet', 'sales');
- * const result = await sdk.query('SELECT * FROM sales WHERE amount > 1000');
- * console.log(result.rows);
+ * Run a semantic-layer query against the project's `.view.yml` /
+ * `.topic.yml` definitions. The server compiles to SQL and executes
+ * through the same connector path as `useQuery`, so result shape
+ * matches.
  *
- * // Clean up when done
- * await sdk.close();
- * ```
+ * Re-runs whenever the input shape changes (deep-compared via JSON).
+ * Use `opts.enabled = false` to defer the first fetch until required
+ * inputs (e.g. a user-picked filter value) are available.
  */
-declare class OxySDK {
-  private client;
-  private reader;
-  constructor(config: OxyConfig);
-  /**
-   * Creates an OxySDK instance asynchronously with support for postMessage authentication
-   *
-   * @param config - Optional configuration overrides
-   * @returns Promise resolving to OxySDK instance
-   *
-   * @example
-   * ```typescript
-   * // In an iframe - automatic postMessage auth
-   * const sdk = await OxySDK.create({
-   *   parentOrigin: 'https://app.example.com',
-   *   projectId: 'my-project-id'
-   * });
-   * ```
-   */
-  static create(config?: Partial<OxyConfig>): Promise<OxySDK>;
-  /**
-   * Load a Parquet file from Oxy and register it for SQL queries
-   *
-   * @param filePath - Path to the parquet file in the app state directory
-   * @param tableName - Name to use for the table in SQL queries
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   * await sdk.loadFile('data/customers.parquet', 'customers');
-   *
-   * const result = await sdk.query(`
-   *   SELECT s.*, c.name
-   *   FROM sales s
-   *   JOIN customers c ON s.customer_id = c.id
-   * `);
-   * ```
-   */
-  loadFile(filePath: string, tableName: string): Promise<void>;
-  /**
-   * Load multiple Parquet files at once
-   *
-   * @param files - Array of file paths and table names
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFiles([
-   *   { filePath: 'data/sales.parquet', tableName: 'sales' },
-   *   { filePath: 'data/customers.parquet', tableName: 'customers' },
-   *   { filePath: 'data/products.parquet', tableName: 'products' }
-   * ]);
-   *
-   * const result = await sdk.query('SELECT * FROM sales');
-   * ```
-   */
-  loadFiles(files: Array<{
-    filePath: string;
-    tableName: string;
-  }>): Promise<void>;
-  /**
-   * Load all data from an app's data container
-   *
-   * This fetches the app's data and registers all parquet files using their container keys as table names.
-   *
-   * @param appPath - Path to the app file
-   * @returns DataContainer with file references
-   *
-   * @example
-   * ```typescript
-   * // If app has data: { sales: { file_path: 'data/sales.parquet' } }
-   * const data = await sdk.loadAppData('dashboard.app.yml');
-   * // Now you can query the 'sales' table
-   * const result = await sdk.query('SELECT * FROM sales LIMIT 10');
-   * ```
-   */
-  loadAppData(appPath: string): Promise<DataContainer | null>;
-  /**
-   * Execute a SQL query against loaded data
-   *
-   * @param sql - SQL query to execute
-   * @returns Query result with columns and rows
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   *
-   * const result = await sdk.query('SELECT product, SUM(amount) as total FROM sales GROUP BY product');
-   * console.log(result.columns); // ['product', 'total']
-   * console.log(result.rows);    // [['Product A', 1000], ['Product B', 2000]]
-   * console.log(result.rowCount); // 2
-   * ```
-   */
-  query(sql: string): Promise<QueryResult>;
-  /**
-   * Get all data from a loaded table
-   *
-   * @param tableName - Name of the table
-   * @param limit - Maximum number of rows (optional)
-   * @returns Query result
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   * const allData = await sdk.getAll('sales');
-   * const first100 = await sdk.getAll('sales', 100);
-   * ```
-   */
-  getAll(tableName: string, limit?: number): Promise<QueryResult>;
-  /**
-   * Get schema information for a loaded table
-   *
-   * @param tableName - Name of the table
-   * @returns Schema information
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   * const schema = await sdk.getSchema('sales');
-   * console.log(schema.columns); // ['column_name', 'column_type', ...]
-   * console.log(schema.rows);    // [['id', 'INTEGER'], ['name', 'VARCHAR'], ...]
-   * ```
-   */
-  getSchema(tableName: string): Promise<QueryResult>;
-  /**
-   * Get row count for a loaded table
-   *
-   * @param tableName - Name of the table
-   * @returns Number of rows
-   *
-   * @example
-   * ```typescript
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   * const count = await sdk.count('sales');
-   * console.log(`Total rows: ${count}`);
-   * ```
-   */
-  count(tableName: string): Promise<number>;
-  /**
-   * Get direct access to the underlying OxyClient
-   *
-   * Useful for advanced operations like listing apps, getting displays, etc.
-   *
-   * @returns The OxyClient instance
-   *
-   * @example
-   * ```typescript
-   * const apps = await sdk.getClient().listApps();
-   * const displays = await sdk.getClient().getDisplays('my-app.app.yml');
-   * ```
-   */
-  getClient(): OxyClient;
-  /**
-   * Get direct access to the underlying ParquetReader
-   *
-   * Useful for advanced operations like registering blobs directly.
-   *
-   * @returns The ParquetReader instance
-   *
-   * @example
-   * ```typescript
-   * const myBlob = new Blob([parquetData]);
-   * await sdk.getReader().registerParquet(myBlob, 'mydata');
-   * ```
-   */
-  getReader(): ParquetReader;
-  /**
-   * Close and cleanup all resources
-   *
-   * This clears all loaded data and releases resources. Call this when you're done with the SDK.
-   *
-   * @example
-   * ```typescript
-   * const sdk = new OxySDK({ apiKey: 'key', projectId: 'project' });
-   * await sdk.loadFile('data/sales.parquet', 'sales');
-   * const result = await sdk.query('SELECT * FROM sales');
-   * await sdk.close(); // Clean up
-   * ```
-   */
-  close(): Promise<void>;
+declare function useSemanticQuery<Row = Record<string, unknown>>(input: UseSemanticQueryInput, opts?: UseSemanticQueryOpts): UseSemanticQueryResult<Row>;
+type ProcedureRunState = "idle" | "running" | "done" | "failed";
+interface UseProcedureRunInput {
+  procedureId: string;
 }
-//#endregion
-//#region src/react.d.ts
-/**
- * Context value provided to child components
- */
-interface OxyContextValue {
-  sdk: OxySDK | null;
-  isLoading: boolean;
+interface UseProcedureRunOpts {
+  /** Polling cadence in ms while running. Default: 2000 (procedures
+   *  are typically minutes-long; tighter cadence wastes resources). */
+  pollIntervalMs?: number;
+  pollIntervalBackoffMs?: number;
+  /** Max client-side wait in ms. Default: 1 hour. */
+  maxWaitMs?: number;
+}
+interface ProcedureProgress {
+  step: string;
+  percent: number;
+}
+interface ProcedureResult {
+  summary: string;
+  outputs: Record<string, unknown>;
+}
+interface UseProcedureRunResult {
+  state: ProcedureRunState;
+  run: (params?: Record<string, unknown>) => void;
+  /** Cancel the in-flight run. Idempotent. */
+  cancel: () => void;
+  progress: ProcedureProgress | null;
+  result: ProcedureResult | null;
   error: Error | null;
 }
 /**
- * Props for OxyProvider component
- */
-interface OxyProviderProps {
-  children: ReactNode;
-  config?: Partial<OxyConfig>;
-  /**
-   * If true, uses async initialization (supports postMessage auth in iframes)
-   * If false, uses synchronous initialization with provided config
-   */
-  useAsync?: boolean;
-  /**
-   * Optional app path to load initial app data from upon initialization
-   */
-  appPath?: string;
-  /**
-   * Optional initial files to preload into the SDK as a mapping of filename to content
-   */
-  files?: Record<string, string>;
-  /**
-   * Called when SDK is successfully initialized
-   */
-  onReady?: (sdk: OxySDK) => void;
-  /**
-   * Called when initialization fails
-   */
-  onError?: (error: Error) => void;
-  /**
-   * Rendered while the SDK is initializing. Defaults to rendering children (no loading UI).
-   */
-  loadingFallback?: ReactNode;
-  /**
-   * Rendered when SDK initialization fails. Receives the error.
-   * Defaults to rendering children (no error UI).
-   */
-  errorFallback?: ReactNode | ((error: Error) => ReactNode);
+ * @beta Long-running procedure runner. The wire shape works end-to-end
+ * (start → poll → cancel; runs survive server restarts via the
+ * `customer_app_procedure_runs` table) but a few rough edges remain
+ * before this is GA-ready:
+ *
+ *   - Hint surfaces for `procedure_not_found` are correct but the
+ *     procedure-discovery rules (which directories the server scans,
+ *     case-sensitivity, branch awareness) aren't documented yet.
+ *   - Cancellation across multi-instance deployments leans on a
+ *     periodic sweep — fine for now, but expect occasional latency
+ *     between `cancel()` and the run actually stopping.
+ *   - Progress reporting requires the procedure to emit named
+ *     steps; bundles get `progress: null` until that lands.
+ *
+ * The API surface is stable; expect breaking changes only if the
+ * server-side `customer_app_procedure_runs` schema changes.
+ */
+declare function useProcedureRun(input: UseProcedureRunInput, opts?: UseProcedureRunOpts): UseProcedureRunResult;
+type AgentRunState = "idle" | "running" | "needs_clarification" | "done" | "failed";
+interface AgentRunEvent {
+  type: string;
+  data: unknown;
+}
+/** SQL produced and (optionally) executed by the agent. Extracted
+ *  from `query_generated` / `query_executed` / `verified_sql` /
+ *  `semantic_query` / `omni_query` SSE events so callers don't have
+ *  to scan the raw event stream themselves. */
+interface AgentSqlArtifact {
+  type: "sql";
+  /** Stable id derived from the SSE event id so React keys stay
+   *  stable across re-renders / reconnects. */
+  id: string;
+  /** Originating UI event type — preserves the verified/semantic/etc.
+   *  flavor in case the renderer wants a badge. */
+  source: string;
+  sql: string;
+  /** Present when the SQL was executed and rows came back. */
+  results?: {
+    columns: string[];
+    rows: unknown[][];
+    rowCount: number;
+  };
+  /** Present when execution failed — surface it so the bundle UI can
+   *  show the failure inline next to the SQL instead of swallowing
+   *  it inside the agent's final answer. */
+  error?: string;
+}
+type AgentArtifact = AgentSqlArtifact;
+interface UseAgentRunInput {
+  agentId: string;
+}
+interface UseAgentRunResult {
+  state: AgentRunState;
+  /** Submit a question and open the SSE stream. */
+  ask: (question: string, opts?: {
+    threadId?: string;
+  }) => void;
+  /** Cancel the in-flight stream + the server-side run. Idempotent. */
+  cancel: () => void;
+  /** Accumulated raw events for advanced consumers. */
+  events: AgentRunEvent[];
+  /** SQL artifacts extracted from the event stream — convenience
+   *  view over `events` so renderers don't have to know which event
+   *  types carry SQL. */
+  artifacts: AgentArtifact[];
+  /** Final answer once a `done` event arrives. Markdown. */
+  answer: string | null;
+  /** Clarification text once a suspension event arrives. */
+  clarification: string | null;
+  /** Thread id used by the active run (stable across follow-ups). */
+  threadId: string | null;
+  /**
+   * @beta Relative path to the full thread view in oxy (e.g.
+   * `/threads/<id>` for local mode, or
+   * `/<org_slug>/workspaces/<ws_id>/threads/<id>` in cloud). Set
+   * once the run starts so a bundle can render a "Continue in Oxy"
+   * link without constructing the URL itself.
+   *
+   * Caveats while in beta:
+   *   - The bundle's origin and the oxy app shell's origin can
+   *     differ in cloud deployments. If they do, this relative URL
+   *     resolves against the bundle's origin and 404s. A future
+   *     release will expose the oxy app origin via the manifest;
+   *     for now, prefix at the call site if you know your
+   *     deployment topology, or hide the link entirely.
+   *   - The thread row may not be queryable until the run produces
+   *     its first event — clicking the link immediately after
+   *     `ask()` can land on a "thread not found" page.
+   */
+  threadUrl: string | null;
+  error: Error | null;
+}
+declare function useAgentRun(input: UseAgentRunInput): UseAgentRunResult;
+interface OxyAnswerProps {
+  /** Markdown answer text from `useAgentRun().answer`. */
+  answer: string | null;
+  /** SQL artifacts from `useAgentRun().artifacts`. */
+  artifacts?: AgentArtifact[];
+  /** Lifecycle state — drives the placeholder, spinner, error UI. */
+  state: AgentRunState;
+  /** Clarification text when `state === "needs_clarification"`. */
+  clarification?: string | null;
+  /** Failure reason when `state === "failed"`. */
+  error?: Error | null;
+  /**
+   * @beta Relative URL to the thread view in oxy — renders a
+   * "Continue in Oxy (beta)" link when set. Pass `null` to suppress
+   * the link entirely; the link is marked beta because the resolved
+   * URL may not reach a live thread in every deployment topology
+   * (see `UseAgentRunResult.threadUrl`).
+   */
+  threadUrl?: string | null;
+  /** Override the link label. Default: "Continue this thread in Oxy". */
+  threadLinkLabel?: string;
+  /** Maximum number of SQL result rows to render per artifact. Older
+   *  rows truncated with a "+N more" note. Default: 10. */
+  maxArtifactRows?: number;
+  /** Class on the outer container — for callers using utility CSS. */
+  className?: string;
 }
 /**
- * Provider component that initializes and provides OxySDK to child components
- *
- * @example
- * ```tsx
- * // Synchronous initialization with config
- * function App() {
- *   return (
- *     <OxyProvider config={{
- *       apiKey: 'your-key',
- *       projectId: 'your-project',
- *       baseUrl: 'https://api.oxy.tech'
- *     }}>
- *       <Dashboard />
- *     </OxyProvider>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Async initialization (for iframe/postMessage auth)
- * function App() {
- *   return (
- *     <OxyProvider
- *       useAsync
- *       config={{ parentOrigin: 'https://app.example.com' }}
- *     >
- *       <Dashboard />
- *     </OxyProvider>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // With environment variables
- * import { createConfig } from '@oxy/sdk';
- *
- * function App() {
- *   return (
- *     <OxyProvider config={createConfig()}>
- *       <Dashboard />
- *     </OxyProvider>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // With loading and error slots
- * function App() {
- *   return (
- *     <OxyProvider
- *       config={createConfig()}
- *       loadingFallback={<div>Loading SDK...</div>}
- *       errorFallback={(error) => <div>Error: {error.message}</div>}
- *     >
- *       <Dashboard />
- *     </OxyProvider>
- *   );
- * }
- * ```
- */
-declare function OxyProvider({
-  children,
-  config,
-  useAsync,
-  appPath,
-  files,
-  onReady,
-  onError,
-  loadingFallback,
-  errorFallback
-}: OxyProviderProps): React.JSX.Element;
-/**
- * Hook to access OxySDK from child components
- *
- * @throws {Error} If used outside of OxyProvider
- * @returns {OxyContextValue} The SDK instance, loading state, and error
- *
- * @example
- * ```tsx
- * function Dashboard() {
- *   const { sdk, isLoading, error } = useOxy();
- *
- *   useEffect(() => {
- *     if (sdk) {
- *       sdk.loadAppData('dashboard.app.yml')
- *         .then(() => sdk.query('SELECT * FROM my_table'))
- *         .then(result => console.log(result));
- *     }
- *   }, [sdk]);
- *
- *   if (isLoading) return <div>Loading SDK...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *   if (!sdk) return null;
- *
- *   return <div>Dashboard</div>;
- * }
- * ```
- */
-declare function useOxy(): OxyContextValue;
-/**
- * Hook to access OxySDK that throws if not ready
- *
- * This is a convenience hook that returns the SDK directly or throws an error if not initialized.
- * Use this when you know the SDK should be ready.
+ * Renders an agent run's answer + artifacts + thread link as a
+ * single block. The default styling is intentionally neutral
+ * (system fonts, gray surfaces) so it blends into any bundle.
  *
- * @throws {Error} If used outside of OxyProvider or if SDK is not initialized
- * @returns {OxySDK} The SDK instance
+ * Designed to be paired with `useAgentRun`:
  *
- * @example
  * ```tsx
- * function DataTable() {
- *   const sdk = useOxySDK();
- *   const [data, setData] = useState(null);
- *
- *   useEffect(() => {
- *     sdk.loadFile('data.parquet', 'data')
- *       .then(() => sdk.query('SELECT * FROM data LIMIT 100'))
- *       .then(setData);
- *   }, [sdk]);
- *
- *   return <table>...</table>;
- * }
+ * const run = useAgentRun({ agentId: "analyst" });
+ * return (
+ *   <>
+ *     <button onClick={() => run.ask("how many users last week?")}>Ask</button>
+ *     <OxyAnswer {...run} />
+ *   </>
+ * );
  * ```
  */
-declare function useOxySDK(): OxySDK;
-//#endregion
-//#region src/auth/postMessage.d.ts
-/**
- * Check if the current context is running inside an iframe
- *
- * @returns true if running in an iframe, false otherwise (including Node.js)
- */
-declare function isInIframe(): boolean;
+declare function OxyAnswer(props: OxyAnswerProps): React.JSX.Element;
+interface OxyChatProps {
+  /** Agent id (matches `<id>.agentic.yml` in the project). */
+  agentId: string;
+  /** Placeholder for the question input. */
+  placeholder?: string;
+  /** Button label. Default: "Ask". */
+  submitLabel?: string;
+  /** Rendered when the user hasn't asked anything yet. */
+  emptyState?: React.ReactNode;
+  /** Forwarded to the inner `<OxyAnswer>`. */
+  maxArtifactRows?: number;
+  /** Class on the outer container. */
+  className?: string;
+}
 /**
- * Request authentication from parent window via postMessage
- *
- * This is the main entry point for iframe-based authentication.
- * It sends a request to the parent window and waits for a response.
+ * Complete drop-in chat surface. One agent, one input, one answer
+ * view. The chat is single-turn by default — each new question
+ * cancels the previous run and clears the answer. Bundles that
+ * want a multi-turn conversation history compose their own UI
+ * using `useAgentRun` directly.
  *
- * @param options - Configuration options for the auth request
- * @returns Promise that resolves with authentication credentials
- * @throws {PostMessageAuthNotInIframeError} If not in an iframe
- * @throws {PostMessageAuthTimeoutError} If parent doesn't respond in time
- * @throws {PostMessageAuthInvalidOriginError} If response from wrong origin
- * @throws {PostMessageAuthInvalidResponseError} If response is malformed
- *
- * @example
- * ```typescript
- * const auth = await requestAuthFromParent({
- *   parentOrigin: 'https://app.example.com',
- *   timeout: 5000
- * });
- * console.log('Received API key:', auth.apiKey);
- * ```
+ * Single-turn keeps the surface dead simple: bundles use this for
+ * the "ask anything about your data" widget that sits next to
+ * structured panels. Multi-turn is rare in those contexts and
+ * better expressed by the bundle.
  */
-declare function requestAuthFromParent(options?: PostMessageAuthOptions): Promise<PostMessageAuthResult>;
+declare function OxyChat(props: OxyChatProps): React.JSX.Element;
 //#endregion
-export { type AppDataResponse, type AppItem, type DataContainer, type DisplayData, type DisplayWithError, type FileReference, type OxyAuthRequestMessage, type OxyAuthResponseMessage, OxyClient, type OxyConfig, type OxyContextValue, OxyProvider, type OxyProviderProps, OxySDK, ParquetReader, PostMessageAuthInvalidOriginError, PostMessageAuthInvalidResponseError, PostMessageAuthNotInIframeError, type PostMessageAuthOptions, type PostMessageAuthResult, PostMessageAuthTimeoutError, type QueryResult, type TableData, createConfig, createConfigAsync, initializeDuckDB, isInIframe, queryParquet, readParquet, requestAuthFromParent, useOxy, useOxySDK };
+export { type AgentArtifact, type AgentRunEvent, type AgentRunState, type AgentSqlArtifact, type AppFetcher, type CustomerAppDebugSnapshot, type CustomerAppErrorReport, type LoadManifestOptions, OxyAnswer, type OxyAnswerProps, OxyApiError, type OxyAppLogLevel, type OxyAppLogger, type OxyAppManifest, OxyAppProvider, type OxyAppProviderProps, OxyChat, type OxyChatProps, type OxyInjectedAppConfig, type ProcedureProgress, type ProcedureResult, type ProcedureRunState, type ResolvedCustomerAppManifest, type SemanticArrayOp, type SemanticDateRangeOp, type SemanticFilter, type SemanticScalarOp, type SemanticTimeDimension, type UseAgentRunInput, type UseAgentRunResult, type UseProcedureRunInput, type UseProcedureRunOpts, type UseProcedureRunResult, type UseQueryInput, type UseQueryOpts, type UseQueryResult, type UseSemanticQueryInput, type UseSemanticQueryOpts, type UseSemanticQueryResult, _resetCustomerAppManifestCacheForTest, getCustomerAppDebug, getOxyAppLogger, interpretCustomerAppError, loadCustomerAppManifest, readInjectedAppConfig, setOxyAppLogger, useAgentRun, useProcedureRun, useQuery, useResolvedManifest, useSemanticQuery };
 //# sourceMappingURL=index.d.cts.map