@oxy-hq/sdk 2.6.0 → 2.9.1

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 
-import { A as UseSemanticQueryOpts, B as CustomAppErrorReport, C as UseProcedureRunInput, D as UseQueryOpts, E as UseQueryInput, F as useProcedureRun, G as OxyAppFunctionManifest, H as apiErrorFromResponse, I as useQuery, J as _resetCustomAppManifestCacheForTest, K as OxyAppManifest, L as useResolvedManifest, M as useAgentRun, N as useFunction, O as UseQueryResult, P as useOxyApp, R as useSemanticQuery, S as UseFunctionResult, T as UseProcedureRunResult, U as interpretCustomAppError, V as OxyApiError, W as LoadManifestOptions, Y as loadCustomAppManifest, _ as SemanticFilter, a as AppFetcher, b as UseAgentRunInput, c as OxyAppProvider, d as OxyChatProps, f as ProcedureProgress, g as SemanticDateRangeOp, h as SemanticArrayOp, i as AgentSqlArtifact, j as UseSemanticQueryResult, k as UseSemanticQueryInput, l as OxyAppProviderProps, m as ProcedureRunState, n as AgentRunEvent, o as OxyAnswer, p as ProcedureResult, q as ResolvedCustomAppManifest, r as AgentRunState, s as OxyAnswerProps, t as AgentArtifact, u as OxyChat, v as SemanticScalarOp, w as UseProcedureRunOpts, x as UseAgentRunResult, y as SemanticTimeDimension, z as useTrackEvent } from "./react-DnBdQ8dG.cjs";
+import { A as UseSemanticQueryOpts, B as CustomAppErrorReport, C as UseProcedureRunInput, D as UseQueryOpts, E as UseQueryInput, F as useProcedureRun, G as OxyAppFunctionManifest, H as apiErrorFromResponse, I as useQuery, J as _resetCustomAppManifestCacheForTest, K as OxyAppManifest, L as useResolvedManifest, M as useAgentRun, N as useFunction, O as UseQueryResult, P as useOxyApp, R as useSemanticQuery, S as UseFunctionResult, T as UseProcedureRunResult, U as interpretCustomAppError, V as OxyApiError, W as LoadManifestOptions, Y as loadCustomAppManifest, _ as SemanticFilter, a as AppFetcher, b as UseAgentRunInput, c as OxyAppProvider, d as OxyChatProps, f as ProcedureProgress, g as SemanticDateRangeOp, h as SemanticArrayOp, i as AgentSqlArtifact, j as UseSemanticQueryResult, k as UseSemanticQueryInput, l as OxyAppProviderProps, m as ProcedureRunState, n as AgentRunEvent, o as OxyAnswer, p as ProcedureResult, q as ResolvedCustomAppManifest, r as AgentRunState, s as OxyAnswerProps, t as AgentArtifact, u as OxyChat, v as SemanticScalarOp, w as UseProcedureRunOpts, x as UseAgentRunResult, y as SemanticTimeDimension, z as useTrackEvent } from "./react-DBG6Pfp_.cjs";
 //#region src/config.d.ts
 /**
  * Configuration for the Oxy SDK
@@ -141,15 +141,38 @@ interface ExplainNode {
   dimension_count?: number;
   children?: ExplainNode[];
 }
+/** Whether a driver's observed move pushes the target the way it actually
+ *  moved (`contributing`) or against it (`counteracting` — it offset part of
+ *  the move rather than causing it). `unknown` when no signed claim is
+ *  available: `direction: unknown` with no coefficient, or a flat
+ *  driver/target. */
+type DriverContribution = "contributing" | "counteracting" | "unknown";
+/** A driver's move split into the part its base forced and the part its own
+ *  ratio contributed. Emitted only when the driver genuinely tracks a sibling
+ *  rather than moving on its own — presence is the claim.
+ *  `base_driven_delta + ratio_driven_delta === driver_delta`. */
+interface PassthroughSplit {
+  base_measure: string;
+  ratio_previous: number;
+  ratio_current: number;
+  base_driven_delta: number;
+  ratio_driven_delta: number;
+}
 interface DriverAttribution {
   driver_measure: string;
   driver_previous: number;
   driver_current: number;
   driver_delta: number;
+  /** Both optional: an `explain_cache` row written before these fields shipped
+   *  is served verbatim, so absent means unclassified — not a default. */
+  direction?: DriverDirection;
+  contribution?: DriverContribution;
   coefficient?: number;
   form: DriverForm;
+  /** Absent for a purely qualitative driver (no coefficient). */
   estimated_target_impact?: number;
   description?: string;
+  passthrough?: PassthroughSplit;
 }
 type ExplainWarning = {
   type: "simpsons_paradox";
@@ -225,12 +248,31 @@ interface OpportunityResult {
   target: string;
   period: [string, string];
   overall_value: number;
-  /** "value_share" (additive) or "equal" (ratios). */
+  /**
+   * "rows" (rate-based additive sizing — the only basis that yields a sized
+   * upside figure), "value_share" (additive) or "equal" (ratios).
+   */
   weight_basis: string;
   dimensions: DimensionOpportunity[];
   skipped_dimensions: SkippedDimension[];
   downstream: PredictImpact[];
 }
+/**
+ * Single-period structural decomposition. The server auto-derives the
+ * baseline as the equal-length window immediately before `period`, then
+ * returns an {@link ExplainResult}-shaped payload (so the same renderers
+ * work). Ignore the delta fields when rendering a pure distribution.
+ */
+interface DistributionRequest {
+  target: string;
+  time_dimension: string;
+  /** `[start, end]` inclusive date strings. */
+  period: [string, string];
+}
+interface TimeDimensionsResponse {
+  /** view name → fully-qualified time-dimension ids (`view.dim`). */
+  by_view: Record<string, string[]>;
+}
 /**
  * Shape of the inner request helper exposed by `OxyClient`. The metric-tree
  * client reuses it to inherit auth headers, timeout, baseUrl, and project
@@ -334,6 +376,13 @@ declare class MetricTreeClient {
 //#region src/anomalies.d.ts
 type AnomalyStatus = "new" | "acknowledged" | "dismissed";
 type AnomalySeverity = "low" | "medium" | "high";
+/** One filter pinning an anomaly (or a failed monitor) to a segment. */
+interface AnomalyFilter {
+  /** Fully-qualified dimension id, e.g. `"sales_daily.restaurant_id"`. */
+  member: string;
+  /** Matched values (OR within a filter). */
+  values: string[];
+}
 /**
  * One row in the anomaly inbox. Detected by `oxy-metric-monitoring` per
  * `.monitor.yml` entry; upserted by repeat scans so unresolved anomalies
@@ -355,6 +404,26 @@ interface Anomaly {
   severity: AnomalySeverity | string;
   status: AnomalyStatus | string;
   label?: string | null;
+  /**
+   * Stable key derived from the monitor's filters (e.g.
+   * `"sales_daily.restaurant_id=loc-abc"`). Empty for chain-wide monitors.
+   */
+  dimension_key: string;
+  /**
+   * Raw filters identifying the segment; `null` for chain-wide monitors.
+   * Always present on the wire (the server serializes it unconditionally),
+   * hence required-nullable rather than optional — same shape as
+   * {@link ScanFailure.filters}.
+   */
+  filters: AnomalyFilter[] | null;
+  /**
+   * Groups consecutive flagged buckets of one segment into a single event, so a
+   * surge spanning Mon/Wed/Thu reads as one problem rather than three. `null`
+   * for rows detected before events existed. This is what
+   * {@link AnomaliesClient.updateStatusBulk} wants as `eventIds` — a status
+   * action applies to the whole event.
+   */
+  event_id?: string | null;
   /** Cached ExplainResult — populated by `POST /anomalies/:id/explain`. */
   explain_cache?: ExplainResult | null;
   explain_cached_at?: string | null;
@@ -363,20 +432,135 @@ interface Anomaly {
 }
 interface ListAnomaliesOptions {
   status?: AnomalyStatus | string;
-  /** Max rows (server caps at 500, defaults to 100). */
+  /**
+   * Max **events** (server caps at 500, defaults to 100). Every bucket of a
+   * returned event comes back, so the row count is `limit × buckets-per-event`.
+   * With `order: "recent"` it is a plain row limit instead.
+   */
   limit?: number;
+  /**
+   * How many **events** to skip (rows, with `order: "recent"`) — same unit as
+   * `limit`, so page `n` is `offset: (n - 1) * limit`. Defaults to 0.
+   *
+   * Bounded: past the server's maximum depth the request is refused with a 400
+   * rather than served a repeat of the last reachable page, so a runaway
+   * `offset += limit` loop ends loudly instead of spinning. Every response
+   * echoes that depth as `max_offset`, so a loop can stop before reaching it.
+   */
+  offset?: number;
+  /**
+   * `"recent"` returns latest-first (`detected_at DESC`). Omit for the default
+   * worst-first ranking by event severity (active events before dismissed).
+   */
+  order?: "recent";
 }
 interface ListAnomaliesResponse {
   anomalies: Anomaly[];
+  /**
+   * Total matching the filter across every page — **events** under the default
+   * ranking, rows under `order: "recent"`. Same unit as `limit`/`offset`, so
+   * `Math.ceil(total / limit)` is the page count. Note it will not equal
+   * `anomalies.length` under the default ranking even on a single page: each
+   * event returns all of its buckets.
+   *
+   * **Absent** in two cases, and a client that pages has to handle both. Send
+   * neither `limit` nor `offset` and you have asked for "the top N", so there
+   * is no total behind the answer — the field is omitted rather than filled
+   * with the page's own length. Pass a `limit` (with `offset: 0` for the first
+   * page) to get a real total to loop against.
+   *
+   * It is also dropped when the count query itself fails: the page rows are
+   * already in hand, and the server serves them without their denominator
+   * rather than failing a request it could answer. So a page you asked for
+   * with `limit` can still come back untotalled — page off `anomalies.length`
+   * and `max_offset` in that case rather than treating it as zero.
+   */
+  total?: number;
+  /**
+   * The page actually served. `limit` is clamped to 1..=500, so it can come
+   * back smaller than you asked for and every page number you compute must
+   * divide by this rather than by what you sent. `offset` is *not* clamped —
+   * too deep a request is refused with a 400 (see `max_offset`), so this echoes
+   * the offset you sent whenever there is a response at all.
+   *
+   * Optional because a replica still running a pre-paging build emits neither,
+   * which is a live shape during a rolling deploy. Fall back to what you asked
+   * for rather than doing arithmetic on `undefined`.
+   */
+  limit?: number;
+  offset?: number;
+  /**
+   * The deepest `offset` the server will serve — past it a request is refused
+   * with a 400. Read it rather than hardcoding a copy: a paging loop bounded by
+   * this stops cleanly instead of ending on an error.
+   */
+  max_offset?: number;
+  /**
+   * Event keys whose buckets were trimmed to the server's per-event cap (50) —
+   * an `event_id`, or `ungrouped:<row id>` for a row detected before events
+   * existed. For those events `anomalies` holds the worst buckets, not all of
+   * them, so a status write should name the event through `updateStatusBulk`'s
+   * `eventIds` rather than enumerating the buckets you received.
+   *
+   * Only meaningful under the default ranking, which pages *events* and
+   * returns each whole — there, an absence means complete. With
+   * `order: "recent"` the page is row-limited, so an event can straddle its
+   * boundary instead; this list stays empty and every event should be treated
+   * as possibly partial.
+   */
+  truncated_events?: string[];
+}
+interface BulkUpdateStatusResponse {
+  /** Buckets actually written. Lower than what you sent when a row was
+   *  deleted, moved out of `onlyStatus`, or belongs to another workspace. */
+  updated: number;
+  /** Distinct anomalies behind those buckets — events, plus standalone
+   *  pre-event rows. The unit a UI counts in, and one only the server can
+   *  compute: naming an event never told you how many buckets it held.
+   *
+   *  An anomaly counts as updated once *any* of its buckets is written. Name
+   *  events through `eventIds` and that is the whole anomaly; name one bucket
+   *  of a long chain through `ids` and this still reports `1` while the rest
+   *  keep their old status. `ids` is for pre-event rows, which hold one bucket
+   *  each — using it for anything else buys a partial write. */
+  events_updated: number;
 }
 interface ScanOptions {
   /** Override the reference "now" date (YYYY-MM-DD) — useful for demos. */
   as_of?: string;
 }
+/** One `.monitor.yml` entry that errored during a scan. */
+interface ScanFailure {
+  measure: string;
+  time_dimension: string;
+  granularity: string;
+  label: string | null;
+  /** Segment key for a `group_by`/filtered monitor; empty for chain-wide. */
+  dimension_key: string;
+  /** Raw filters identifying the segment; null for chain-wide monitors. */
+  filters: AnomalyFilter[] | null;
+  error: string;
+}
 interface ScanResponse {
   monitors_scanned: number;
   monitors_failed: number;
   anomalies_persisted: number;
+  /**
+   * True when the scan is still running server-side (it exceeded the 55 s
+   * synchronous window, or a scan started within the last 60 s and this call
+   * was debounced). The counts are all `0` in that case — they are NOT a
+   * "nothing found" result. Refetch with `list()` after a short delay.
+   */
+  pending: boolean;
+  /**
+   * Per-monitor failures. Empty array (never absent) on a clean scan and on
+   * the `pending` path, where failures aren't known yet.
+   */
+  failures: ScanFailure[];
+}
+interface ExplainOptions {
+  /** Recompute even when the row already has a cached result. */
+  refresh?: boolean;
 }
 type RequestFn = <T>(endpoint: string, options?: RequestInit) => Promise<T>;
 /**
@@ -399,12 +583,17 @@ declare class AnomaliesClient {
   private path;
   private buildQuery;
   /**
-   * List anomalies in the inbox, newest first.
+   * List anomalies in the inbox, ranked worst-first by event severity (active
+   * events before dismissed). Pass `order: "recent"` for latest-first.
    *
    * @example
    * ```typescript
    * // Open / unresolved anomalies only
    * const { anomalies } = await client.anomalies.list({ status: "new" });
+   *
+   * // Second page of 25 events
+   * const page2 = await client.anomalies.list({ limit: 25, offset: 25 });
+   * console.log(`${(page2.offset ?? 25) + 1}+ of ${page2.total ?? "?"}`);
    * ```
    */
   list(options?: ListAnomaliesOptions): Promise<ListAnomaliesResponse>;
@@ -413,11 +602,20 @@ declare class AnomaliesClient {
    * workspace, runs the detector, and upserts matching rows into the
    * inbox. Returns counts of scanned / failed / persisted.
    *
+   * Long-running: the server waits up to 55 s, then returns
+   * `pending: true` with zeroed counts while the scan finishes in the
+   * background. Always check `pending` before treating `0` as "nothing
+   * found", and refetch with {@link list} shortly after.
+   *
    * @example
    * ```typescript
    * // Scan against a known-good reference date (matches the seed dataset)
    * const result = await client.anomalies.scan({ as_of: "2025-12-15" });
-   * console.log(`${result.anomalies_persisted} anomalies detected`);
+   * if (result.pending) {
+   *   console.log("scan still running — refetch shortly");
+   * } else {
+   *   console.log(`${result.anomalies_persisted} anomalies detected`);
+   * }
    * ```
    */
   scan(options?: ScanOptions): Promise<ScanResponse>;
@@ -425,13 +623,84 @@ declare class AnomaliesClient {
    * Update an anomaly's status (acknowledge / dismiss / re-open).
    */
   updateStatus(anomalyId: string, status: AnomalyStatus): Promise<Anomaly>;
+  /**
+   * Update many anomalies in one request — the batch form of
+   * {@link updateStatus}. Identifiers outside the workspace are skipped rather
+   * than erroring, so `updated` (rows written) can be lower than what you sent.
+   * At most 2000 identifiers across both lists.
+   *
+   * **Prefer `eventIds`.** Inbox actions are per *event*, and a list response
+   * caps how many buckets it returns per event — so acking the bucket ids you
+   * received can leave the tail of a long chain behind, `new`, under a clean
+   * success. Naming the event lets the server write all of it. `ids` is for
+   * rows with no `event_id` (detected before events existed), which can only
+   * be named individually.
+   *
+   * `onlyStatuses` says which of an event's buckets may move. An event can span
+   * statuses, so an unbounded write resurrects buckets that were dismissed on
+   * purpose — which is why omitting it takes a scope rather than no bound at
+   * all: the live statuses (`["new", "acknowledged"]`) for an ack or dismiss,
+   * and all three for `status: "new"`, since reopening is how a dismissed
+   * anomaly comes back. The server applies that same default, so the safe
+   * behaviour does not depend on going through this client. Pass `[]` to opt
+   * out of the bound entirely.
+   *
+   * @example
+   * ```typescript
+   * const { anomalies } = await client.anomalies.list({ status: "new", limit: 50, offset: 0 });
+   * // Both lists: events by id, and pre-event rows (no `event_id`) by their own.
+   * const eventIds = [...new Set(anomalies.flatMap((a) => (a.event_id ? [a.event_id] : [])))];
+   * const ids = anomalies.filter((a) => !a.event_id).map((a) => a.id);
+   * const { updated } = await client.anomalies.updateStatusBulk(
+   *   { ids, eventIds, onlyStatuses: ["new", "acknowledged"] },
+   *   "acknowledged"
+   * );
+   * ```
+   */
+  updateStatusBulk(target: {
+    ids?: string[];
+    eventIds?: string[];
+    onlyStatuses?: AnomalyStatus[];
+  }, status: AnomalyStatus): Promise<BulkUpdateStatusResponse>;
   /**
    * Run the metric-tree `explain` for an anomaly and cache the result on
-   * the row. Subsequent calls return the cached `ExplainResult` instantly.
+   * the row. Subsequent calls return the cached `ExplainResult` instantly;
+   * pass `{ refresh: true }` to bust the cache and recompute.
+   *
+   * The uncached path runs a 20-30 s recursive driver search — budget for it
+   * (or read `explain_cache` off the row from {@link list} when it's already
+   * populated).
    */
-  explain(anomalyId: string): Promise<ExplainResult>;
+  explain(anomalyId: string, options?: ExplainOptions): Promise<ExplainResult>;
 }
 //#endregion
+//#region src/custom-app/base64.d.ts
+/**
+ * Encode bytes as standard (padded) base64.
+ *
+ * ```ts
+ * const pdf = new Uint8Array(await renderReport());
+ * await ctx.email.send({
+ *   to: ctx.user.email,
+ *   subject: "Report",
+ *   text: "attached",
+ *   attachments: [{ filename: "report.pdf", content: bytesToBase64(pdf) }]
+ * });
+ * ```
+ *
+ * For **text** you generated, skip this entirely and pass the string with
+ * `encoding: "utf8"` — it needs no encoder and stays byte-exact for non-ASCII.
+ */
+declare function bytesToBase64(input: Uint8Array | ArrayBuffer | ArrayBufferView): string;
+/**
+ * Decode standard base64 to bytes — e.g. the body from
+ * `ctx.storage.get(key, { encoding: "base64" })`.
+ *
+ * Throws on malformed input rather than returning a short buffer: a truncated
+ * decode that reports success is a corrupt file nobody notices.
+ */
+declare function base64ToBytes(base64: string): Uint8Array;
+//#endregion
 //#region src/custom-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
@@ -481,11 +750,60 @@ interface OxyFunctionRequest {
 }
 /** A single row from a `ctx.query` / `ctx.queryStream` result. */
 type OxyFunctionRow = Record<string, unknown>;
-/** Identity of the invoking user (route) or the system identity (schedule/airway). */
+/** One org team the caller belongs to, as reported by {@link OxyFunctionUser.teams}. */
+interface OxyOrgTeam {
+  id: string;
+  name: string;
+}
+/**
+ * Who — or what — invoked this function.
+ *
+ * `"system"` means **no caller to attribute this to** — not necessarily "no
+ * human caused it". A schedule tick, an Airway transform step, and an operator's
+ * manual *Run now* all take this path: they run under the org owner's `id` (the
+ * invocation record needs a real user FK) with every caller field absent. So on
+ * a manual run a person really did click, and there is still no way to reach
+ * them; the platform does not carry the triggering operator through the job
+ * queue.
+ *
+ * Any branch that emails "the person who clicked" or renders a personal view
+ * must check this rather than sniff the synthetic `email` — and must have a
+ * sensible answer for the case where there is nobody to send to.
+ */
+type OxyIdentityKind = "user" | "system";
+/**
+ * Identity of the invoking user (route) or the system identity (schedule,
+ * Airway step, or a manual job run).
+ *
+ * Assembled server-side on every invocation from the authenticated session —
+ * **nothing on it is client-supplied**, which is the entire reason to read
+ * identity here instead of from the request body. See
+ * `internal-docs/custom-apps-user-identity.md` for the full contract, including
+ * what the client-side `useShellContext()` can and cannot be trusted for.
+ */
 interface OxyFunctionUser {
+  /**
+   * `users.id`. On a `"system"` invocation this is the org owner's id and not a
+   * caller — check {@link kind} before attributing anything to it.
+   */
   id: string;
+  /** Their email, or `schedule+<fn>@system.oxy` when {@link kind} is `"system"`. */
   email: string;
+  /**
+   * The org that owns this app — the tenant boundary for anything the function
+   * reads or writes.
+   *
+   * Servers before 2026-08-21 mistakenly sent this as `org_id`, so `orgId` read
+   * `undefined` there; both keys are populated now. If your function filters SQL
+   * on it, that is exactly the bug to re-check.
+   */
   orgId: string;
+  /** Display name. Absent on a `"system"` invocation. User-controlled free text —
+   *  fine for a greeting or an audit row, never a key, and escape it before it
+   *  reaches HTML or SQL. */
+  name?: string;
+  /** Avatar URL. Absent when unset or on a `"system"` invocation. */
+  picture?: string;
   /**
    * The caller's role **within this app**, derived server-side from app
    * membership (with org-owner / Oxy-staff break-glass). Absent when they hold
@@ -502,20 +820,104 @@ interface OxyFunctionUser {
    *
    * Note it is deliberately NOT the org role: an app admin administers one app
    * without holding org-Admin (which also carries billing and member management).
+   *
+   * A `"system"` invocation runs under the org owner, so this reads `"admin"`
+   * there — a schedule carries owner authority by construction. Add a
+   * {@link kind} check when a surface must be human-only.
    */
   appRole?: "admin" | "member";
+  /**
+   * The caller's role in the owning **org**. Absent when they reach the app
+   * without an org membership (Oxy staff on break-glass) or on a `"system"`
+   * invocation.
+   *
+   * Informational, not a gate — org standing and app standing are separate
+   * rings. Use it to explain ("ask your org admin to connect a warehouse"), to
+   * label, or to route; gate on {@link appRole}.
+   */
+  orgRole?: "owner" | "admin" | "member";
+  /**
+   * The org teams the caller belongs to, name-sorted, and scoped to this app's
+   * org — teams they hold in other orgs are never reported. Empty when they
+   * belong to none.
+   *
+   * Optional because a server older than 2026-08-21 does not send it: use
+   * `ctx.user.teams?.some(...)`, never `ctx.user.teams.some(...)`, or the
+   * function throws on that server rather than degrading.
+   *
+   * Useful for *shaping* a view (default the Finance team to the finance tab).
+   * Not a permission: a team only grants anything on an app through an app team
+   * grant, which is already folded into {@link appRole}. Gating on a team name
+   * invents a permission the platform cannot revoke.
+   */
+  teams?: OxyOrgTeam[];
+  /**
+   * Whether there is a caller to attribute this invocation to.
+   *
+   * On a current server this is exact — `ctx.user.kind === "system"` is the
+   * check.
+   *
+   * Optional for the same reason as {@link teams}: a server older than
+   * 2026-08-21 does not send it. Note there is no safe *inference* to fall back
+   * on, in either direction — `=== "system"` reads `false` for a cron tick, and
+   * `!== "user"` reads `true` for a real person. An older server genuinely
+   * cannot tell you.
+   *
+   * So if you must support one, don't infer: a schedule invokes the function
+   * with the `input` you configured on it, which is yours to mark.
+   *
+   * ```ts
+   * const body = JSON.parse(req.body || "{}");
+   * const isSystem = ctx.user.kind ? ctx.user.kind === "system" : body._trigger === "schedule";
+   * ```
+   */
+  kind?: OxyIdentityKind;
 }
 /** Result of a `ctx.fetch` call. */
 interface OxyFetchResult {
   status: number;
+  /** Response body, decoded per the requested {@link OxyFetchInit.encoding}. */
   body: string;
+  /** Echoes how `body` was encoded (`"utf8"` unless base64 was requested). */
+  encoding?: "utf8" | "base64";
 }
+/**
+ * `init` for `ctx.fetch` — the standard `RequestInit` fields the host honours
+ * (`method`, `headers`, `body`) plus how to decode the response.
+ */
+type OxyFetchInit = RequestInit & {
+  /**
+   * How to decode the response body. `"utf8"` (default) is **lossy for
+   * binary** — every non-UTF-8 byte becomes U+FFFD, so a fetched PDF/PNG comes
+   * back corrupt. Pass `"base64"` for any binary response, e.g. to hand it
+   * straight to an email attachment.
+   */
+  encoding?: "utf8" | "base64";
+};
 /** `ctx.warehouse.*` — writes to one of the app's configured destination databases. */
 interface OxyWarehouseApi {
   insert(database: string, table: string, rows: OxyFunctionRow[]): Promise<unknown>;
   exec(database: string, sql: string): Promise<unknown>;
   upsert(database: string, table: string, rows: OxyFunctionRow[], conflictColumns: string[]): Promise<unknown>;
 }
+/**
+ * The handle `ctx.tx` passes to your callback — a pinned connection with an
+ * open transaction.
+ *
+ * Both methods take **bound parameters** (`$1`, `$2`, …). Never build SQL by
+ * concatenating request data: `ctx.warehouse.exec` takes a bare string, but a
+ * transaction exists for surfaces that accept end-user input, and placeholders
+ * are the only thing that makes that safe.
+ *
+ * The handle is live only for the duration of the callback. Using it after the
+ * callback returns throws — it is not a connection you can stash.
+ */
+interface OxyTransaction {
+  /** Run a row-returning statement (including `INSERT … RETURNING`). */
+  query(sql: string, params?: unknown[]): Promise<OxyFunctionRow[]>;
+  /** Run a statement for its effect; resolves to the number of rows affected. */
+  exec(sql: string, params?: unknown[]): Promise<number>;
+}
 /** `ctx.secrets` — write app-scoped secrets (gated by the `secrets.write` capability). */
 interface OxySecretsApi {
   set(key: string, value: string): Promise<void>;
@@ -561,6 +963,9 @@ interface EmailSendInput {
    * Files to attach. Max 20 per send, and **10 MiB decoded in total** — SES
    * caps a whole message near 40 MB, so for anything larger store the file with
    * {@link OxyStorageApi} and email a presigned link instead of inlining it.
+   *
+   * `content` is base64 by default; for generated text set
+   * `encoding: "utf8"` and attach the string as-is.
    */
   attachments?: EmailAttachment[];
 }
@@ -568,8 +973,23 @@ interface EmailSendInput {
 interface EmailAttachment {
   /** Filename shown to the recipient. Required; path separators are stripped. */
   filename: string;
-  /** File bytes, **base64-encoded** (the only way binary crosses the isolate boundary). */
+  /**
+   * File contents, interpreted per {@link EmailAttachment.encoding} — base64 by
+   * default, which is the only way binary crosses the isolate boundary.
+   */
   content: string;
+  /**
+   * How `content` is encoded. Defaults to `"base64"`.
+   *
+   * Use `"utf8"` to attach text the function just generated (CSV, JSON, HTML)
+   * — it needs no encoder and is byte-exact for non-ASCII. `btoa` is the wrong
+   * tool there: it encodes U+0080..U+00FF as *Latin1*, so accented text comes
+   * out as mojibake rather than as an error. For binary, take base64 straight
+   * from the source — `ctx.storage.get(key, { encoding: "base64" })` or
+   * `ctx.fetch(url, { encoding: "base64" })` — or {@link bytesToBase64} for a
+   * `Uint8Array` you built yourself.
+   */
+  encoding?: "base64" | "utf8";
   /** MIME type; defaults to `application/octet-stream`. */
   contentType?: string;
   /** Render inline (e.g. an image referenced as `cid:<contentId>`) instead of as a download. */
@@ -619,6 +1039,30 @@ interface StorageUploadUrl {
   key: string;
   /** ISO-8601 expiry of the presigned URL. */
   expiresAt: string;
+  /**
+   * Retention tag for this key, present only when your app declares a matching
+   * `storage.retention` rule in `oxy-app.json` (e.g. `"oxy-ttl=30d"`).
+   *
+   * **When present, the upload MUST send it as the `x-amz-tagging` header** — it
+   * is bound into the signature, so omitting it fails the PUT with a signature
+   * mismatch rather than storing an untagged object:
+   *
+   * ```ts
+   * const { url, tagging } = await ctx.storage.getUploadUrl({ ... });
+   * await fetch(url, {
+   *   method: "PUT",
+   *   body: file,
+   *   headers: {
+   *     "Content-Type": file.type,
+   *     ...(tagging ? { "x-amz-tagging": tagging } : {}),
+   *   },
+   * });
+   * ```
+   *
+   * Signing it is deliberate: a browser that could drop the header could opt any
+   * upload out of the app's own retention policy.
+   */
+  tagging?: string;
 }
 /** A minted presigned download. */
 interface StorageDownloadUrl {
@@ -762,9 +1206,45 @@ interface OxyFunctionContext {
   queryStream(sql: string, opts?: {
     batchSize?: number;
   }): AsyncGenerator<OxyFunctionRow[], void, unknown>;
-  /** SSRF-allowlisted outbound HTTP with a response-size cap. */
-  fetch(url: string, init?: RequestInit): Promise<OxyFetchResult>;
+  /**
+   * SSRF-allowlisted outbound HTTP with a response-size cap. Pass
+   * `{ encoding: "base64" }` for a binary response — the default UTF-8 decode
+   * corrupts it.
+   */
+  fetch(url: string, init?: OxyFetchInit): Promise<OxyFetchResult>;
   warehouse: OxyWarehouseApi;
+  /**
+   * Run several statements atomically on one connection: commits when your
+   * callback resolves, rolls back when it throws, and rethrows your error
+   * either way. Resolves to whatever the callback returns.
+   *
+   * `database` must be in this function's manifest `destinations` — a
+   * transaction is a write, and the same fail-closed allowlist applies. Postgres
+   * only; other backends reject `ctx.tx` rather than faking it.
+   *
+   * **Do not catch a failed statement and return normally.** A statement the
+   * server rejects aborts the whole transaction, and `COMMIT` on an aborted
+   * transaction does not fail — Postgres applies nothing and reports success —
+   * so `ctx.tx` refuses to commit and throws instead, naming the statement that
+   * poisoned it. Let the error propagate.
+   *
+   * ```ts
+   * const orderId = await ctx.tx("appdb", async (tx) => {
+   *   const [{ id }] = await tx.query(
+   *     "INSERT INTO orders (table_no) VALUES ($1) RETURNING id",
+   *     [tableNo],
+   *   );
+   *   for (const it of items) {
+   *     await tx.exec(
+   *       "INSERT INTO order_items (order_id, sku, qty) VALUES ($1, $2, $3)",
+   *       [id, it.sku, it.qty],
+   *     );
+   *   }
+   *   return id;
+   * });
+   * ```
+   */
+  tx<T>(database: string, fn: (tx: OxyTransaction) => Promise<T> | T): Promise<T>;
   secrets: OxySecretsApi;
   semantic: OxySemanticApi;
   airway: OxyAirwayApi;
@@ -813,5 +1293,333 @@ declare function setOxyAppLogger(logger: OxyAppLogger | null): void;
 /** Used by the SDK internals; not part of the public surface. */
 declare function getOxyAppLogger(): OxyAppLogger;
 //#endregion
-export { type AgentArtifact, type AgentRunEvent, type AgentRunState, type AgentSqlArtifact, AnomaliesClient, type Anomaly, type AnomalySeverity, type AnomalyStatus, type AppFetcher, type CustomAppDebugSnapshot, type CustomAppErrorReport, type DimensionOpportunity, type DriverAttribution, type DriverConfidence, type DriverDirection, type DriverForm, type DriverStrength, type EdgeKind, type EmailAttachment, type EmailSendInput, type EmailSendResult, type ExplainConfigOverride, type ExplainNode, type ExplainRequest, type ExplainResult, type ExplainSibling, type ExplainWarning, type ListAnomaliesOptions, type ListAnomaliesResponse, type LoadManifestOptions, type MetricEdge, type MetricNode, type MetricTree, MetricTreeClient, type OpportunityRequest, type OpportunityResult, type OxyAirwayApi, OxyAnswer, type OxyAnswerProps, OxyApiError, type OxyAppFunctionManifest, type OxyAppLogLevel, type OxyAppLogger, type OxyAppManifest, OxyAppProvider, type OxyAppProviderProps, OxyChat, type OxyChatProps, type OxyEmailApi, type OxyFetchResult, type OxyFunctionContext, type OxyFunctionHandler, type OxyFunctionRequest, type OxyFunctionRow, type OxyFunctionUser, type OxyInjectedAppConfig, type OxySecretsApi, type OxySemanticApi, type OxyStorageApi, type OxyWarehouseApi, type PredictChange, type PredictImpact, type PredictResult, type ProcedureProgress, type ProcedureResult, type ProcedureRunState, type ResolvedCustomAppManifest, type ScanOptions, type ScanResponse, type SegmentOpportunity, type SemanticArrayOp, type SemanticDateRangeOp, type SemanticFilter, type SemanticScalarOp, type SemanticTimeDimension, type SensitivityDriver, type SensitivityResult, type SkippedDimension, type SplitKind, type StorageDownloadUrl, type StorageListPage, type StorageObject, type StoragePutOptions, type StoragePutResult, type StorageUploadUrl, type StorageUploadUrlInput, type UseAgentRunInput, type UseAgentRunResult, type UseFunctionResult, type UseProcedureRunInput, type UseProcedureRunOpts, type UseProcedureRunResult, type UseQueryInput, type UseQueryOpts, type UseQueryResult, type UseSemanticQueryInput, type UseSemanticQueryOpts, type UseSemanticQueryResult, _resetCustomAppManifestCacheForTest, apiErrorFromResponse, getCustomAppDebug, getOxyAppLogger, interpretCustomAppError, loadCustomAppManifest, readInjectedAppConfig, setOxyAppLogger, useAgentRun, useFunction, useOxyApp, useProcedureRun, useQuery, useResolvedManifest, useSemanticQuery, useTrackEvent };
+//#region src/custom-app/metric-tree-hooks.d.ts
+/** Shared result envelope for every metric-tree hook. */
+interface MetricTreeHookResult<Data> {
+  data: Data | null;
+  loading: boolean;
+  error: Error | null;
+  /** Force a re-run, bypassing nothing — the server honors `?refresh`. */
+  refetch: () => void;
+}
+interface EndpointOpts {
+  /** Set false to skip the request (e.g. waiting on a user selection). */
+  enabled?: boolean;
+}
+interface UseMetricTreeOpts extends EndpointOpts {
+  /** Optional measure id to root the returned subtree at. */
+  root?: string;
+}
+/**
+ * The project's metric tree — measures (nodes) and their component /
+ * driver relationships (edges) — or the subtree rooted at `opts.root`.
+ * The structural backbone every other metric-tree analysis reads against.
+ */
+declare function useMetricTree(opts?: UseMetricTreeOpts): MetricTreeHookResult<MetricTree>;
+/**
+ * Ranked drivers of `measureId`, by influence — the "what moves this
+ * measure" question. Pass `null` to stay idle until a measure is chosen.
+ */
+declare function useSensitivity(measureId: string | null, opts?: EndpointOpts): MetricTreeHookResult<SensitivityResult>;
+/**
+ * Propagate hypothetical `(measure, delta)` changes upward through the
+ * tree and return the estimated impact on every downstream measure — a
+ * pure metric-tree walk, no warehouse query. Pass `null` to stay idle.
+ */
+declare function usePredict(changes: PredictChange[] | null, opts?: EndpointOpts): MetricTreeHookResult<PredictResult>;
+/**
+ * Period-over-period root-cause decomposition: recursively splits the
+ * target measure by components and dimensions until the move concentrates.
+ * This is the heavy one — it can fire many warehouse queries and the
+ * server caps it at 45s. Pass `null` to defer until periods are chosen.
+ */
+declare function useExplain(request: ExplainRequest | null, opts?: EndpointOpts): MetricTreeHookResult<ExplainResult>;
+/**
+ * Single-period distribution of a measure — an {@link ExplainResult}
+ * against an auto-derived immediately-prior baseline. Same renderers as
+ * `useExplain`; ignore the delta fields for a pure distribution view.
+ */
+declare function useDistribution(request: DistributionRequest | null, opts?: EndpointOpts): MetricTreeHookResult<ExplainResult>;
+/**
+ * Segment opportunity sizing for a measure over a period: finds
+ * underperforming segments and sizes the addressable upside of closing
+ * each rate gap against a benchmark peer. Pass `null` to stay idle until
+ * a target + period are chosen.
+ */
+declare function useOpportunity(request: OpportunityRequest | null, opts?: EndpointOpts): MetricTreeHookResult<OpportunityResult>;
+/**
+ * The queryable time dimensions per view (`view.dim` ids) — what a
+ * bundle offers as the period axis for `explain` / `opportunity` /
+ * `distribution` instead of hardcoding a curated map.
+ */
+declare function useTimeDimensions(opts?: EndpointOpts): MetricTreeHookResult<TimeDimensionsResponse>;
+//#endregion
+//#region src/custom-app/sse.d.ts
+/**
+ * Read a `text/event-stream` response, invoking `onEvent` with each parsed
+ * JSON frame. Frames that fail to parse are skipped (a malformed frame must
+ * not tear down the whole stream). Resolves when the body closes.
+ */
+declare function readJsonSseStream<E>(resp: Response, onEvent: (event: E) => void): Promise<void>;
+//#endregion
+//#region src/worldModel.d.ts
+/** How a measure aggregates across the entity hierarchy. */
+type AdditivityClass = "additive" | "non_additive" | "passthrough";
+interface WorldModelMeasure {
+  name: string;
+  measure_type: string;
+  additivity: AdditivityClass;
+  description?: string | null;
+  expr?: string | null;
+  label?: string | null;
+  /** True when the measure decomposes into a metric-tree driver breakdown. */
+  has_breakdown?: boolean;
+}
+/** A measure promoted onto this entity from a descendant view. */
+interface WorldModelInducedMeasure extends WorldModelMeasure {
+  /** View the measure is actually declared on. */
+  promoted_from: string;
+  /** Promotion path from the declaring view up to this entity. */
+  path: string[];
+}
+interface WorldModelDimension {
+  name: string;
+  dim_type: string;
+  description?: string | null;
+  label?: string | null;
+}
+interface WorldModelEntity {
+  id: string;
+  label: string;
+  view: string;
+  description?: string | null;
+  depth: number;
+  dimensions: WorldModelDimension[];
+  own_measures: WorldModelMeasure[];
+  induced_measures: WorldModelInducedMeasure[];
+  display_field?: string | null;
+}
+/** A promotion edge: measures on `from` promote up to `to`. */
+interface WorldModelEdge {
+  from: string;
+  to: string;
+  functional: boolean;
+}
+interface WorldModel {
+  entities: WorldModelEntity[];
+  edges: WorldModelEdge[];
+}
+interface WmInstance {
+  key: string;
+  display: string;
+}
+interface WmInstancesResponse {
+  total: number;
+  has_more: boolean;
+  items: WmInstance[];
+}
+interface WmEntityCount {
+  matched: number;
+  total: number;
+  /** Sample of reachable descendant rows at this grain (display strings). */
+  sample?: string[];
+  /** Navigation keys aligned with `sample`. */
+  sample_keys?: string[];
+}
+interface WmFilterCountsResponse {
+  counts: Record<string, WmEntityCount>;
+}
+interface WmBreakdownNode {
+  /** Metric node id `view.measure`. */
+  id: string;
+  view: string;
+  measure: string;
+  label: string;
+  measure_type: string;
+  is_composite: boolean;
+  is_root: boolean;
+  expr?: string | null;
+  /** Filled by `value` frames; null while pending. */
+  value: string | null;
+  unvalued_reason: string | null;
+}
+interface WmBreakdownEdge {
+  from: string;
+  to: string;
+  operator: "add" | "sub" | "mul" | "div";
+  sign: number;
+}
+/** One frame of the measure-breakdown stream. The `init` frame carries the
+ *  graph shape; `value` frames fill node values in as they resolve. */
+type WmMeasureBreakdownEvent = {
+  kind: "init";
+  root: string;
+  nodes: Omit<WmBreakdownNode, "value" | "unvalued_reason">[];
+  edges: WmBreakdownEdge[];
+} | {
+  kind: "value";
+  node_id: string;
+  value: string | null;
+  unvalued_reason: string | null;
+} | {
+  kind: "done";
+};
+/** Accumulated breakdown — the shape `useMeasureBreakdown` folds the
+ *  stream into. */
+interface WmMeasureBreakdown {
+  root: string;
+  nodes: WmBreakdownNode[];
+  edges: WmBreakdownEdge[];
+}
+//#endregion
+//#region src/custom-app/world-model-hooks.d.ts
+interface UseWorldModelGraphResult {
+  data: WorldModel | null;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+/**
+ * The world-model graph — entities (nodes), their measures/dimensions, and
+ * how measures promote across the entity hierarchy (edges). Applies the
+ * project's `.world-model.yml` display config server-side.
+ *
+ * @remarks
+ * This returns the raw semantic-layer entity graph. For the higher-level
+ * node-paradigm interface (`world.metric(id)` speaking `expand` / `explain` /
+ * `size`), use {@link useWorldModel} from `./world-node` instead.
+ */
+declare function useWorldModelGraph(opts?: {
+  enabled?: boolean;
+}): UseWorldModelGraphResult;
+interface UseWorldModelInstancesOpts {
+  /** Substring/prefix search over the entity's display field. */
+  search?: string;
+  /** Max rows to return (default 50 server-side). */
+  limit?: number;
+  enabled?: boolean;
+}
+interface UseWorldModelInstancesResult {
+  data: WmInstancesResponse | null;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+/**
+ * List the instances (rows) of `entityId` — a bounded, searchable picker
+ * over the entity's primary keys + display label. Pass `null` for `entityId`
+ * to stay idle until an entity is chosen.
+ */
+declare function useWorldModelInstances(entityId: string | null, opts?: UseWorldModelInstancesOpts): UseWorldModelInstancesResult;
+interface UseMeasureBreakdownResult {
+  /** Accumulated breakdown graph; null until the `init` frame. */
+  breakdown: WmMeasureBreakdown | null;
+  loading: boolean;
+  done: boolean;
+  error: Error | null;
+}
+/**
+ * Stream the driver-tree breakdown of one instance's measure — the metric
+ * decomposition (add/sub/mul/div component graph) with each node's value
+ * filling in as it resolves. This is the per-instance RCA view. Pass `null`
+ * for `measure` to stay idle.
+ */
+declare function useMeasureBreakdown(entityId: string | null, keyValue: string | null, measure: string | null): UseMeasureBreakdownResult;
+//#endregion
+//#region src/custom-app/world-node.d.ts
+/** A `dimension → value` scope narrowed onto a node via {@link MetricHandle.drill}. */
+type MetricScope = Readonly<Record<string, string>>;
+/** Options for {@link MetricHandle.explain} — an {@link ExplainRequest} minus
+ *  the `target`, which the handle supplies from its own id. */
+type ExplainOpts = Omit<ExplainRequest, "target">;
+/** Options for {@link MetricHandle.size} — an {@link OpportunityRequest} minus
+ *  the `target`. */
+type SizeOpts = Omit<OpportunityRequest, "target">;
+/** One child revealed by {@link MetricHandle.expand}: the child measure's
+ *  node, the edge that connects it to the parent, and a handle to recurse. */
+interface ExpandedNode {
+  /** The child measure (a component or a driver of the parent). */
+  node: MetricNode;
+  /** The parent → child edge — `kind`, `direction`, `strength`, `form`, … */
+  edge: MetricEdge;
+  /** A live handle on the child, carrying the parent's scope. */
+  handle: MetricHandle;
+}
+/**
+ * A live handle on one metric node. Carry it around and call a verb; every
+ * verb returns either more nodes (`expand`), a scoped handle (`drill`), or an
+ * analysis result (`explain` / `size` / `drivers`).
+ */
+interface MetricHandle {
+  /** Fully-qualified measure id (`view.measure`). */
+  readonly id: string;
+  /** The scope narrowed onto this handle by `drill` (empty for a root handle). */
+  readonly scope: MetricScope;
+  /** The measure's own tree node (label, expr, is_composite). */
+  node(signal?: AbortSignal): Promise<MetricNode>;
+  /** One hop of relationships — the metric's components and drivers as child nodes. */
+  expand(signal?: AbortSignal): Promise<ExpandedNode[]>;
+  /** The declared drivers of this measure, ranked by influence (sensitivity). */
+  drivers(signal?: AbortSignal): Promise<SensitivityResult>;
+  /** Root-cause a period-over-period move: why it dropped or climbed. */
+  explain(opts: ExplainOpts, signal?: AbortSignal): Promise<ExplainResult>;
+  /** Compare this node to its peers across each dimension and size the gap. */
+  size(opts: SizeOpts, signal?: AbortSignal): Promise<OpportunityResult>;
+  /** Narrow into a segment or entity instance — returns a scoped handle. */
+  drill(scope: Record<string, string>): MetricHandle;
+}
+/**
+ * The World Model interface, scoped to one project. The whole surface hangs
+ * off this: grab a {@link MetricHandle} with `metric(id)` and the handle
+ * speaks the verbs, or pull the whole graph with `tree(root?)`.
+ */
+interface WorldModelApi {
+  /** The active project id, or `null` before `<OxyAppProvider>` resolves one. */
+  readonly projectId: string | null;
+  /** The metric tree, rooted anywhere you like (default: the whole tree). */
+  tree(root?: string, signal?: AbortSignal): Promise<MetricTree>;
+  /** A live handle on one measure node. */
+  metric(id: string): MetricHandle;
+}
+/**
+ * Thrown by the value verbs (`explain` / `size`) when called on a handle that
+ * has been `drill`ed. The metric-tree backend cannot yet scope these analyses
+ * to a segment, so failing loud beats returning population numbers for a
+ * question that asked about one segment.
+ */
+declare class WorldModelScopeUnsupportedError extends Error {
+  readonly code = "world_model_scope_unsupported";
+  readonly scope: MetricScope;
+  constructor(verb: string, scope: MetricScope);
+}
+/**
+ * Build a {@link WorldModelApi} over a project id and fetcher. Framework-
+ * agnostic — `useWorldModel()` wraps this for React, but it is directly
+ * unit-testable with a mock fetcher.
+ */
+declare function createWorldModel(projectId: string | null, fetcher: AppFetcher): WorldModelApi;
+/**
+ * The World Model node interface, scoped to the active `<OxyAppProvider>`
+ * project. Returns a stable {@link WorldModelApi} — grab a node with
+ * `world.metric(id)` and let it speak the verbs.
+ *
+ * @example
+ * ```tsx
+ * const world = useWorldModel();
+ * const revenue = world.metric("orders.net_revenue");
+ * const children = await revenue.expand();       // components + drivers
+ * const rca = await revenue.explain({
+ *   time_dimension: "orders.order_date",
+ *   current_period: ["2026-06-01", "2026-06-30"],
+ *   previous_period: ["2026-05-01", "2026-05-31"],
+ * });
+ * ```
+ *
+ * @remarks
+ * This is the node-paradigm hook. For the raw semantic-layer entity/measure
+ * graph, use {@link useWorldModelGraph} instead.
+ */
+declare function useWorldModel(): WorldModelApi;
+//#endregion
+export { type AdditivityClass, type AgentArtifact, type AgentRunEvent, type AgentRunState, type AgentSqlArtifact, AnomaliesClient, type Anomaly, type AnomalyFilter, type AnomalySeverity, type AnomalyStatus, type AppFetcher, type BulkUpdateStatusResponse, type CustomAppDebugSnapshot, type CustomAppErrorReport, type DimensionOpportunity, type DistributionRequest, type DriverAttribution, type DriverConfidence, type DriverDirection, type DriverForm, type DriverStrength, type EdgeKind, type EmailAttachment, type EmailSendInput, type EmailSendResult, type ExpandedNode, type ExplainConfigOverride, type ExplainNode, type ExplainOptions, type ExplainOpts, type ExplainRequest, type ExplainResult, type ExplainSibling, type ExplainWarning, type ListAnomaliesOptions, type ListAnomaliesResponse, type LoadManifestOptions, type MetricEdge, type MetricHandle, type MetricNode, type MetricScope, type MetricTree, MetricTreeClient, type MetricTreeHookResult, type OpportunityRequest, type OpportunityResult, type OxyAirwayApi, OxyAnswer, type OxyAnswerProps, OxyApiError, type OxyAppFunctionManifest, type OxyAppLogLevel, type OxyAppLogger, type OxyAppManifest, OxyAppProvider, type OxyAppProviderProps, OxyChat, type OxyChatProps, type OxyEmailApi, type OxyFetchResult, type OxyFunctionContext, type OxyFunctionHandler, type OxyFunctionRequest, type OxyFunctionRow, type OxyFunctionUser, type OxyIdentityKind, type OxyInjectedAppConfig, type OxyOrgTeam, type OxySecretsApi, type OxySemanticApi, type OxyStorageApi, type OxyTransaction, type OxyWarehouseApi, type PredictChange, type PredictImpact, type PredictResult, type ProcedureProgress, type ProcedureResult, type ProcedureRunState, type ResolvedCustomAppManifest, type ScanFailure, type ScanOptions, type ScanResponse, type SegmentOpportunity, type SemanticArrayOp, type SemanticDateRangeOp, type SemanticFilter, type SemanticScalarOp, type SemanticTimeDimension, type SensitivityDriver, type SensitivityResult, type SizeOpts, type SkippedDimension, type SplitKind, type StorageDownloadUrl, type StorageListPage, type StorageObject, type StoragePutOptions, type StoragePutResult, type StorageUploadUrl, type StorageUploadUrlInput, type TimeDimensionsResponse, type UseAgentRunInput, type UseAgentRunResult, type UseFunctionResult, type UseMeasureBreakdownResult, type UseMetricTreeOpts, type UseProcedureRunInput, type UseProcedureRunOpts, type UseProcedureRunResult, type UseQueryInput, type UseQueryOpts, type UseQueryResult, type UseSemanticQueryInput, type UseSemanticQueryOpts, type UseSemanticQueryResult, type UseWorldModelGraphResult, type UseWorldModelInstancesOpts, type UseWorldModelInstancesResult, type WmBreakdownEdge, type WmBreakdownNode, type WmEntityCount, type WmFilterCountsResponse, type WmInstance, type WmInstancesResponse, type WmMeasureBreakdown, type WmMeasureBreakdownEvent, type WorldModel, type WorldModelApi, type WorldModelDimension, type WorldModelEdge, type WorldModelEntity, type WorldModelInducedMeasure, type WorldModelMeasure, WorldModelScopeUnsupportedError, _resetCustomAppManifestCacheForTest, apiErrorFromResponse, base64ToBytes, bytesToBase64, createWorldModel, getCustomAppDebug, getOxyAppLogger, interpretCustomAppError, loadCustomAppManifest, readInjectedAppConfig, readJsonSseStream, setOxyAppLogger, useAgentRun, useDistribution, useExplain, useFunction, useMeasureBreakdown, useMetricTree, useOpportunity, useOxyApp, usePredict, useProcedureRun, useQuery, useResolvedManifest, useSemanticQuery, useSensitivity, useTimeDimensions, useTrackEvent, useWorldModel, useWorldModelGraph, useWorldModelInstances };
 //# sourceMappingURL=index.d.cts.map