@ai-matrx/api 0.0.0-stage → 0.1.0

package/dist/human-resources.js

@@ -0,0 +1,148 @@
+// src/generated/human-resources.ts
+var $hrIdentitySsnReveal = { m: "POST", p: "/hr/identity/{identity_id}/ssn/reveal", d: "aidream", a: "user", o: "required", n: "human-resources.hr_identity_ssn_reveal" };
+function hrIdentitySsnReveal(api, args, options) {
+  return api.call($hrIdentitySsnReveal, args, options);
+}
+var $hrIdentitySsnStore = { m: "POST", p: "/hr/identity/{identity_id}/ssn", d: "aidream", a: "user", o: "required", n: "human-resources.hr_identity_ssn_store" };
+function hrIdentitySsnStore(api, args, options) {
+  return api.call($hrIdentitySsnStore, args, options);
+}
+var $hrIdentitySsnFingerprint = { m: "POST", p: "/hr/identity/ssn/fingerprint", d: "aidream", a: "user", o: "required", n: "human-resources.hr_identity_ssn_fingerprint" };
+function hrIdentitySsnFingerprint(api, args, options) {
+  return api.call($hrIdentitySsnFingerprint, args, options);
+}
+var $hrVerificationLettersGenerate = { m: "POST", p: "/hr/verification-letters/{letter_id}/generate", d: "aidream", a: "user", o: "required", n: "human-resources.hr_verification_letters_generate" };
+function hrVerificationLettersGenerate(api, args, options) {
+  return api.call($hrVerificationLettersGenerate, args, options);
+}
+var $hrExportsFormatsList = { m: "GET", p: "/hr/exports/formats", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_formats_list" };
+function hrExportsFormatsList(api, args, options) {
+  return api.call($hrExportsFormatsList, args, options);
+}
+var $hrExportsPayrollPreview = { m: "POST", p: "/hr/exports/payroll/preview", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_payroll_preview" };
+function hrExportsPayrollPreview(api, args, options) {
+  return api.call($hrExportsPayrollPreview, args, options);
+}
+var $hrExportsPayrollCreate = { m: "POST", p: "/hr/exports/payroll", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_payroll_create" };
+function hrExportsPayrollCreate(api, args, options) {
+  return api.call($hrExportsPayrollCreate, args, options);
+}
+var $hrExportsTimesheetCreate = { m: "POST", p: "/hr/exports/timesheet", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_timesheet_create" };
+function hrExportsTimesheetCreate(api, args, options) {
+  return api.call($hrExportsTimesheetCreate, args, options);
+}
+var $hrExportsGet = { m: "GET", p: "/hr/exports/{export_id}", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_get" };
+function hrExportsGet(api, args, options) {
+  return api.call($hrExportsGet, args, options);
+}
+var $hrExportsArtifactGet = { m: "GET", p: "/hr/exports/{export_id}/artifact", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_artifact_get" };
+function hrExportsArtifactGet(api, args, options) {
+  return api.call($hrExportsArtifactGet, args, options);
+}
+var $hrExportsAcknowledge = { m: "POST", p: "/hr/exports/{export_id}/acknowledge", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_acknowledge" };
+function hrExportsAcknowledge(api, args, options) {
+  return api.call($hrExportsAcknowledge, args, options);
+}
+var $hrExportsFail = { m: "POST", p: "/hr/exports/{export_id}/fail", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_fail" };
+function hrExportsFail(api, args, options) {
+  return api.call($hrExportsFail, args, options);
+}
+var $hrExportsSupersede = { m: "POST", p: "/hr/exports/{export_id}/supersede", d: "aidream", a: "user", o: "required", n: "human-resources.hr_exports_supersede" };
+function hrExportsSupersede(api, args, options) {
+  return api.call($hrExportsSupersede, args, options);
+}
+var $hrProvidersBindingsList = { m: "GET", p: "/hr/providers/{seam}/bindings", d: "aidream", a: "user", o: "required", n: "human-resources.hr_providers_bindings_list" };
+function hrProvidersBindingsList(api, args, options) {
+  return api.call($hrProvidersBindingsList, args, options);
+}
+var $hrProvidersDispatch = { m: "POST", p: "/hr/providers/{seam}/dispatch", d: "aidream", a: "user", o: "required", n: "human-resources.hr_providers_dispatch" };
+function hrProvidersDispatch(api, args, options) {
+  return api.call($hrProvidersDispatch, args, options);
+}
+var $hrProvidersResultsRecord = { m: "POST", p: "/hr/providers/{seam}/results", d: "aidream", a: "user", o: "required", n: "human-resources.hr_providers_results_record" };
+function hrProvidersResultsRecord(api, args, options) {
+  return api.call($hrProvidersResultsRecord, args, options);
+}
+var $hrProvidersSync = { m: "POST", p: "/hr/providers/{seam}/sync", d: "aidream", a: "user", o: "required", n: "human-resources.hr_providers_sync" };
+function hrProvidersSync(api, args, options) {
+  return api.call($hrProvidersSync, args, options);
+}
+var $hrHooksProviderWebhook = { m: "POST", p: "/hooks/providers/{seam}/{provider_key}", d: "aidream", a: "scoped", o: "required", n: "human-resources.hr_hooks_provider_webhook" };
+function hrHooksProviderWebhook(api, args, options) {
+  return api.call($hrHooksProviderWebhook, args, options);
+}
+var $hrCalcOvertime = { m: "POST", p: "/hr/calc/overtime", d: "aidream", a: "user", o: "required", n: "human-resources.hr_calc_overtime" };
+function hrCalcOvertime(api, args, options) {
+  return api.call($hrCalcOvertime, args, options);
+}
+var $hrCalcBreakPremium = { m: "POST", p: "/hr/calc/break-premium", d: "aidream", a: "user", o: "required", n: "human-resources.hr_calc_break_premium" };
+function hrCalcBreakPremium(api, args, options) {
+  return api.call($hrCalcBreakPremium, args, options);
+}
+var $hrTimeOvertimeEvaluate = { m: "POST", p: "/hr/time/overtime/evaluate", d: "aidream", a: "user", o: "required", n: "human-resources.hr_time_overtime_evaluate" };
+function hrTimeOvertimeEvaluate(api, args, options) {
+  return api.call($hrTimeOvertimeEvaluate, args, options);
+}
+var $hrTimeRecompute = { m: "POST", p: "/hr/time/recompute", d: "aidream", a: "user", o: "required", n: "human-resources.hr_time_recompute" };
+function hrTimeRecompute(api, args, options) {
+  return api.call($hrTimeRecompute, args, options);
+}
+var $hrTimeExceptionsScan = { m: "POST", p: "/hr/time/exceptions/scan", d: "aidream", a: "user", o: "required", n: "human-resources.hr_time_exceptions_scan" };
+function hrTimeExceptionsScan(api, args, options) {
+  return api.call($hrTimeExceptionsScan, args, options);
+}
+var $hrTimeOvertimeScan = { m: "POST", p: "/hr/time/overtime/scan", d: "aidream", a: "user", o: "required", n: "human-resources.hr_time_overtime_scan" };
+function hrTimeOvertimeScan(api, args, options) {
+  return api.call($hrTimeOvertimeScan, args, options);
+}
+var $hrCalcLeaveAccrual = { m: "POST", p: "/hr/calc/leave-accrual", d: "aidream", a: "user", o: "required", n: "human-resources.hr_calc_leave_accrual" };
+function hrCalcLeaveAccrual(api, args, options) {
+  return api.call($hrCalcLeaveAccrual, args, options);
+}
+var $hrCalcCarryover = { m: "POST", p: "/hr/calc/carryover", d: "aidream", a: "user", o: "required", n: "human-resources.hr_calc_carryover" };
+function hrCalcCarryover(api, args, options) {
+  return api.call($hrCalcCarryover, args, options);
+}
+var $hrAccrualsRun = { m: "POST", p: "/hr/accruals/run", d: "aidream", a: "user", o: "required", n: "human-resources.hr_accruals_run" };
+function hrAccrualsRun(api, args, options) {
+  return api.call($hrAccrualsRun, args, options);
+}
+var $hrAccrualsCarryoverRun = { m: "POST", p: "/hr/accruals/carryover/run", d: "aidream", a: "user", o: "required", n: "human-resources.hr_accruals_carryover_run" };
+function hrAccrualsCarryoverRun(api, args, options) {
+  return api.call($hrAccrualsCarryoverRun, args, options);
+}
+var TABLE = {
+  "POST /hr/identity/{identity_id}/ssn/reveal": $hrIdentitySsnReveal,
+  "POST /hr/identity/{identity_id}/ssn": $hrIdentitySsnStore,
+  "POST /hr/identity/ssn/fingerprint": $hrIdentitySsnFingerprint,
+  "POST /hr/verification-letters/{letter_id}/generate": $hrVerificationLettersGenerate,
+  "GET /hr/exports/formats": $hrExportsFormatsList,
+  "POST /hr/exports/payroll/preview": $hrExportsPayrollPreview,
+  "POST /hr/exports/payroll": $hrExportsPayrollCreate,
+  "POST /hr/exports/timesheet": $hrExportsTimesheetCreate,
+  "GET /hr/exports/{export_id}": $hrExportsGet,
+  "GET /hr/exports/{export_id}/artifact": $hrExportsArtifactGet,
+  "POST /hr/exports/{export_id}/acknowledge": $hrExportsAcknowledge,
+  "POST /hr/exports/{export_id}/fail": $hrExportsFail,
+  "POST /hr/exports/{export_id}/supersede": $hrExportsSupersede,
+  "GET /hr/providers/{seam}/bindings": $hrProvidersBindingsList,
+  "POST /hr/providers/{seam}/dispatch": $hrProvidersDispatch,
+  "POST /hr/providers/{seam}/results": $hrProvidersResultsRecord,
+  "POST /hr/providers/{seam}/sync": $hrProvidersSync,
+  "POST /hooks/providers/{seam}/{provider_key}": $hrHooksProviderWebhook,
+  "POST /hr/calc/overtime": $hrCalcOvertime,
+  "POST /hr/calc/break-premium": $hrCalcBreakPremium,
+  "POST /hr/time/overtime/evaluate": $hrTimeOvertimeEvaluate,
+  "POST /hr/time/recompute": $hrTimeRecompute,
+  "POST /hr/time/exceptions/scan": $hrTimeExceptionsScan,
+  "POST /hr/time/overtime/scan": $hrTimeOvertimeScan,
+  "POST /hr/calc/leave-accrual": $hrCalcLeaveAccrual,
+  "POST /hr/calc/carryover": $hrCalcCarryover,
+  "POST /hr/accruals/run": $hrAccrualsRun,
+  "POST /hr/accruals/carryover/run": $hrAccrualsCarryoverRun
+};
+function call(api, key, args, options) {
+  return api.call(TABLE[key], args, options);
+}
+
+export { call, hrAccrualsCarryoverRun, hrAccrualsRun, hrCalcBreakPremium, hrCalcCarryover, hrCalcLeaveAccrual, hrCalcOvertime, hrExportsAcknowledge, hrExportsArtifactGet, hrExportsFail, hrExportsFormatsList, hrExportsGet, hrExportsPayrollCreate, hrExportsPayrollPreview, hrExportsSupersede, hrExportsTimesheetCreate, hrHooksProviderWebhook, hrIdentitySsnFingerprint, hrIdentitySsnReveal, hrIdentitySsnStore, hrProvidersBindingsList, hrProvidersDispatch, hrProvidersResultsRecord, hrProvidersSync, hrTimeExceptionsScan, hrTimeOvertimeEvaluate, hrTimeOvertimeScan, hrTimeRecompute, hrVerificationLettersGenerate };

package/dist/index-C2E-Cp19.d.ts

@@ -0,0 +1,385 @@
+import { CredentialsSetting } from './credentials.js';
+
+/**
+ * Canonical AI Matrx NDJSON wire kernel.
+ *
+ * This module is deliberately independent of React, Redux, Next.js, Supabase,
+ * and generated application types. Every Matrx client uses it to turn the
+ * backend's byte stream into the same normalized `{ event, data }` envelopes.
+ * Host runtimes remain responsible for HTTP/auth errors and for deciding what
+ * each event means in their state model.
+ */
+interface MatrxStreamEnvelope<TData = unknown> {
+    event: string;
+    /** Immutable emitter segment; transport sequence is scoped to this id. */
+    stream_id?: string;
+    data: TData;
+    /** Monotonic transport sequence from full envelopes, when supplied. */
+    stream_seq?: number;
+}
+interface MatrxNdjsonIssue {
+    line: string;
+    error: unknown;
+    /** One-based physical NDJSON line number. */
+    lineNumber: number;
+    /** True when an unterminated trailing fragment was parsed by `finish()`. */
+    atCompletion: boolean;
+}
+interface MatrxStreamEnvelopeObservation {
+    /** Exact parsed JSON value before compact/full normalization. */
+    raw: unknown;
+    envelope: MatrxStreamEnvelope;
+    line: string;
+    lineNumber: number;
+    atCompletion: boolean;
+}
+interface MatrxNdjsonFramerOptions {
+    /** Malformed JSON is non-fatal, but it must never disappear silently. */
+    onMalformedLine?: (issue: MatrxNdjsonIssue) => void;
+    /** Valid JSON with no recognized Matrx event envelope is also non-fatal. */
+    onUnknownEnvelope?: (value: unknown) => void;
+    /** Observe every valid envelope without changing or consuming it. */
+    onValidEnvelope?: (observation: MatrxStreamEnvelopeObservation) => void;
+}
+interface ReadMatrxNdjsonOptions extends MatrxNdjsonFramerOptions {
+    signal?: AbortSignal;
+    /** Maximum normalized events read ahead of the iterator consumer. */
+    maxReadAhead?: number;
+}
+interface MatrxNdjsonFramer {
+    /** Push a text fragment. Fragments may split JSON tokens or line endings. */
+    pushText(fragment: string): MatrxStreamEnvelope[];
+    /** Push a byte fragment. UTF-8 code points may span calls. */
+    pushBytes(fragment: Uint8Array): MatrxStreamEnvelope[];
+    /** Parse the final unterminated line and flush any pending UTF-8 bytes. */
+    finish(): MatrxStreamEnvelope[];
+}
+declare const DEFAULT_MATRX_NDJSON_READ_AHEAD = 64;
+/**
+ * Normalize both supported Matrx wire shapes:
+ *
+ * - full: `{ "event": "chunk", "data": { "text": "..." } }`
+ * - compact chunk: `{ "e": "c", "t": "..." }`
+ * - compact reasoning: `{ "e": "r", "t": "..." }`
+ */
+declare function normalizeMatrxStreamEnvelope(value: unknown): MatrxStreamEnvelope | null;
+/**
+ * Create the transport-independent NDJSON framer used by the stream reader.
+ * Browser extensions, desktop bridges, WebSockets, and tests can feed it
+ * fragmented strings or bytes without constructing a `ReadableStream`.
+ */
+declare function createMatrxNdjsonFramer(options?: MatrxNdjsonFramerOptions): MatrxNdjsonFramer;
+/**
+ * Read and normalize a Matrx NDJSON response body with bounded background
+ * read-ahead. Consumer work does not stall the network until `maxReadAhead`
+ * complete events are waiting; the bound prevents an abandoned or blocked
+ * consumer from growing memory without limit.
+ */
+declare function readMatrxNdjsonStream(body: ReadableStream<Uint8Array>, options?: ReadMatrxNdjsonOptions): AsyncGenerator<MatrxStreamEnvelope, void, undefined>;
+
+/**
+ * `@ai-matrx/agents/stream/sse` — the Matrx SSE frame kernel.
+ *
+ * Two Matrx clients hand-rolled the identical `text/event-stream` framing —
+ * the same separator regex, the same field parsing, the same CRLF incident —
+ * for the durable rejoin endpoints (`/runtime/.../events/stream`,
+ * `/runs/.../events/stream`). This module is that framing extracted ONCE, as a
+ * pure incremental parser, so a host keeps only what is genuinely host policy:
+ * the fetch, the stall timer, the retry budget, and what each event MEANS.
+ *
+ * Contract, mirroring `stream/ndjson`:
+ * - Pure and effect-free: no fetch, no timers, no globals. Importing this
+ *   module performs no work.
+ * - Incremental across arbitrary chunk boundaries: a frame split anywhere —
+ *   mid-line, mid-separator, mid-UTF-8 when using the byte reader — parses
+ *   identically to one delivered whole.
+ * - All three SSE line terminators (`\r\n`, `\n`, `\r`) and all three frame
+ *   separators are handled — the CRLF-vs-LF divergence that bit production is
+ *   covered by construction and by test.
+ * - Comment-only frames (heartbeats, `:` lines) ARE emitted (with
+ *   `data === null`) because hosts use any parsed frame as liveness proof to
+ *   reset stall timers and retry budgets. Frames with data join multi-line
+ *   `data:` fields with `\n` per the SSE spec.
+ * - `id:` is surfaced raw AND, when it is a safe integer, as `seq` — the
+ *   `Last-Event-ID` cursor both Matrx rejoin endpoints use for durable replay.
+ *   Cursor ADVANCEMENT (`seq > cursor`) stays host-side, next to the retry.
+ */
+interface MatrxSseFrame {
+    /** `event:` field; the SSE default "message" when absent. */
+    event: string;
+    /** `id:` field, raw, when present. */
+    id: string | null;
+    /**
+     * `id:` parsed as a non-negative safe integer, else null. Matrx rejoin
+     * streams use integer ids as the `Last-Event-ID` replay cursor.
+     */
+    seq: number | null;
+    /**
+     * Joined `data:` lines (`\n`-separated per spec), or null for a frame with
+     * no data field at all (e.g. a comment-only heartbeat). An empty-string
+     * data field is `""`, not null.
+     */
+    data: string | null;
+}
+/** Parse ONE complete frame's text (no trailing separator). */
+declare function parseMatrxSseFrame(frame: string): MatrxSseFrame;
+interface MatrxSseFramer {
+    /** Feed a decoded text chunk; returns every frame it completed. */
+    push(chunk: string): MatrxSseFrame[];
+    /**
+     * Signal end of input. A non-empty trailing buffer is an UNTERMINATED frame:
+     * per the SSE spec it was never dispatched, so it is returned separately for
+     * the host to treat as diagnostic, never as a delivered event.
+     */
+    flush(): {
+        incomplete: string | null;
+    };
+}
+/** Incremental SSE framer over already-decoded text. */
+declare function createMatrxSseFramer(): MatrxSseFramer;
+interface ReadMatrxSseOptions {
+    /**
+     * Called with any unterminated trailing text at stream end (a frame the
+     * server never finished — diagnostic, not a delivered event).
+     */
+    onIncomplete?: (text: string) => void;
+}
+/**
+ * Async-iterate the frames of a byte stream (e.g. `response.body`), handling
+ * split UTF-8 across chunk boundaries. Cancellation follows the reader: abort
+ * the fetch and the iterator ends; a transport error after complete frames
+ * were yielded surfaces AFTER those frames, with its original cause.
+ */
+declare function readMatrxSseStream(stream: ReadableStream<Uint8Array>, options?: ReadMatrxSseOptions): AsyncGenerator<MatrxSseFrame, void, undefined>;
+
+/**
+ * GENERATED by @ai-matrx/api scripts/generate.mjs from aidream/api-contract — never edit by hand.
+ * CONTRACT_SHA256 50a790edb39e682b46e0fa9e674faf5ce2a0ba7de2cd01930a497fca4c47844a
+ */
+/** The server contract's hash; the Python `matrx-api` and any native client carry the same value. */
+declare const CONTRACT_SHA256 = "50a790edb39e682b46e0fa9e674faf5ce2a0ba7de2cd01930a497fca4c47844a";
+/** Which deployment answers (api-deployments.json): default base URLs and the existing env names that override them. */
+declare const DEPLOYMENTS: {
+    readonly files: {
+        readonly app: "files-standalone";
+        readonly baseUrl: {
+            readonly production: "https://files.matrxserver.com";
+            readonly localhost: "http://127.0.0.1:8090";
+        };
+        readonly env: {
+            readonly browser: "NEXT_PUBLIC_FILES_URL";
+            readonly browser_local: "NEXT_PUBLIC_FILES_URL_LOCAL";
+            readonly server: "MATRX_FILES_URL";
+        };
+    };
+    readonly scraper: {
+        readonly app: "scraper-server";
+        readonly baseUrl: {
+            readonly production: "https://scraper.app.matrxserver.com";
+            readonly localhost: "http://localhost:8001";
+        };
+        readonly env: {
+            readonly browser: "NEXT_PUBLIC_SCRAPER_URL";
+            readonly browser_local: "NEXT_PUBLIC_SCRAPER_URL_LOCAL";
+            readonly server: "MATRX_SCRAPER_URL";
+            readonly service_token: "MATRX_SCRAPER_TOKEN";
+        };
+    };
+    readonly seo: {
+        readonly app: "seo-standalone";
+        readonly baseUrl: {
+            readonly production: "https://seo.matrxserver.com";
+            readonly localhost: "http://127.0.0.1:8081";
+        };
+        readonly env: {
+            readonly browser: "NEXT_PUBLIC_SEO_URL";
+            readonly browser_local: "NEXT_PUBLIC_SEO_URL_LOCAL";
+        };
+    };
+    readonly "sandbox-orchestrator": {
+        readonly app: "sandbox-orchestrator";
+        readonly baseUrl: {
+            readonly production: "https://orchestrator.dev.codematrx.com";
+        };
+        readonly env: {
+            readonly server: "SANDBOX_ORCHESTRATOR_URL";
+            readonly service_token: "SANDBOX_ORCHESTRATOR_API_KEY";
+        };
+    };
+    readonly "matrx-local": {
+        readonly app: "matrx-local";
+        readonly baseUrl: {
+            readonly localhost: "http://127.0.0.1:22140";
+        };
+        readonly env: {
+            readonly port_base: "MATRX_PORT_BASE";
+        };
+    };
+    readonly "cloud-browser-streaming": {
+        readonly app: "cloud-browser-streaming";
+        readonly baseUrl: {};
+        readonly env: {};
+    };
+    readonly "cloud-browser-worker": {
+        readonly app: "cloud-browser-worker";
+        readonly baseUrl: {};
+        readonly env: {};
+    };
+    readonly "hosted-box": {
+        readonly app: "hosted-box";
+        readonly baseUrl: {};
+        readonly env: {};
+    };
+    readonly aidream: {
+        readonly app: "aidream-main";
+        readonly baseUrl: {
+            readonly production: "https://server.app.matrxserver.com";
+            readonly localhost: "http://localhost:8000";
+        };
+        readonly env: {
+            readonly browser: "NEXT_PUBLIC_BACKEND_URL_PROD";
+            readonly server: "MATRX_AIDREAM_URL";
+            readonly service_token: "MATRX_AIDREAM_SERVICE_TOKEN";
+            readonly sandbox_service_token: "AIDREAM_SANDBOX_SERVICE_TOKEN";
+        };
+    };
+};
+type DeploymentName = keyof typeof DEPLOYMENTS;
+/** Every generated domain section (`@ai-matrx/api/<domain>`). */
+declare const DOMAINS: readonly ["account", "agents", "ai", "apps", "architecture", "audio", "chat", "code", "commerce", "communications", "computer", "content", "crm", "data", "education", "files", "human-resources", "integrations", "intelligence", "knowledge", "legal", "marketing", "masterwork", "media", "platform", "publish", "web", "workflows"];
+
+/**
+ * `createApi` — the ONE client of every AI Matrx server.
+ *
+ * Every generated operation (`@ai-matrx/api/<domain>`) is a standalone
+ * function that hands this client a small {@link OperationDescriptor} straight
+ * from the server contract: method, path template, which deployment answers
+ * (`api-deployments.json`), the auth tier, the organization rule and the
+ * stream kind. The client owns everything else, once:
+ *
+ * - base URL per deployment (production / localhost defaults from the
+ *   deployment map, host overrides per service);
+ * - the ONE credentials setting (five kinds, `credentials.ts`);
+ * - the organization binding, honouring each operation's `x-matrx-org`:
+ *   `required` fails closed before the wire, `optional` sends one when bound,
+ *   `exempt` never sends one;
+ * - `X-Request-Id` on every call;
+ * - connect/total timeouts (`net/resilient-fetch`) and retry of idempotent
+ *   reads (`net/retry`);
+ * - one error model (`MatrxApiError`, `NetError`, `OrganizationContextError`);
+ * - stream parsing (NDJSON, SSE, bytes, and the conditional `*_or_json`).
+ *
+ * No Supabase, no React, no state: a host injects identity, never policy.
+ */
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+/** The contract's `x-matrx-auth` tiers. */
+type AuthTier = "public" | "guest" | "user" | "api_key" | "service" | "scoped" | "admin" | "loopback_token" | "loopback_open";
+/** The contract's `x-matrx-org` rules. */
+type OrgRule = "required" | "optional" | "exempt";
+/** The contract's `x-matrx-stream` kinds. */
+type StreamKind = "none" | "ndjson" | "sse" | "bytes" | "ndjson_or_json" | "sse_or_json" | "bytes_or_json";
+/**
+ * One operation, as the generator writes it. Short keys keep thousands of
+ * descriptors small; only the operations an app imports are ever bundled.
+ */
+interface OperationDescriptor {
+    /** HTTP method. */
+    readonly m: HttpMethod;
+    /** Path template as the deployment serves it (`/files/{file_id}`). */
+    readonly p: string;
+    /** The deployment that answers (`api-deployments.json` service name). */
+    readonly d: DeploymentName;
+    /** Auth tier. */
+    readonly a: AuthTier;
+    /** Organization rule. */
+    readonly o: OrgRule;
+    /** Stream kind; omitted = plain JSON. */
+    readonly s?: StreamKind;
+    /** Stable name `<domain>.<op>` (diagnostics, request logs). */
+    readonly n: string;
+}
+type Environment = "production" | "localhost";
+interface ApiRequestInfo {
+    readonly operation: string;
+    readonly method: HttpMethod;
+    readonly url: string;
+    readonly requestId: string;
+    readonly deployment: DeploymentName;
+}
+interface CreateApiOptions {
+    /** The ONE credentials setting: a credential, a getter, or a `CredentialsPort`. */
+    credentials?: CredentialsSetting;
+    /** The bound organization (value or getter). Sent per each operation's org rule. */
+    organizationId?: string | null | (() => string | null | undefined);
+    /** Which default base URLs to use. Default `"production"`. */
+    environment?: Environment;
+    /** Per-deployment base URL overrides (no trailing slash), e.g. `{ aidream: "http://localhost:8000" }`. */
+    baseUrls?: Partial<Record<DeploymentName, string>>;
+    /** Fully dynamic routing; wins over `baseUrls`. Return undefined to fall through. */
+    resolveBaseUrl?: (deployment: DeploymentName, operation: OperationDescriptor) => string | undefined;
+    /** Max ms request start → response headers. Default 15 000. */
+    connectTimeoutMs?: number;
+    /** Max ms for the whole request. Default null (streams are long-lived). */
+    totalTimeoutMs?: number | null;
+    /** Attempts for idempotent reads (GET/HEAD) on transport failures. Default 3; 1 disables. */
+    retryAttempts?: number;
+    /** Mints the `X-Request-Id`. Default `crypto.randomUUID()`. */
+    requestId?: () => string;
+    /** Extra headers on every call (never overrides credentials or org). */
+    headers?: Record<string, string>;
+    /** Observability sink; the client works fully without it. */
+    onRequest?: (info: ApiRequestInfo) => void;
+}
+/** Per-call options. */
+interface CallOptions {
+    signal?: AbortSignal;
+    /** This call's organization; wins over the bound one. */
+    organizationId?: string;
+    headers?: Record<string, string>;
+    connectTimeoutMs?: number;
+    totalTimeoutMs?: number | null;
+}
+/** The arguments a generated operation accepts (each operation narrows them). */
+interface OperationArgs {
+    path?: Record<string, string | number> | undefined;
+    query?: object | undefined;
+    body?: unknown;
+}
+/** A parsed stream. `requestId` is the `X-Request-Id` this call carried. */
+interface ApiStream<E> extends AsyncIterable<E> {
+    readonly response: Response;
+    readonly requestId: string;
+    /** Abort the underlying request. */
+    cancel(): void;
+}
+/** A conditional stream: the server answered with JSON (e.g. a cached result) or a stream. */
+type JsonOrStream<J, E> = {
+    readonly kind: "json";
+    readonly data: J;
+} | {
+    readonly kind: "stream";
+    readonly stream: ApiStream<E>;
+};
+type NdjsonEvent = MatrxStreamEnvelope;
+type SseEvent = MatrxSseFrame;
+interface Api {
+    /** Send one operation; plain JSON operations resolve to the parsed body. */
+    call<T>(op: OperationDescriptor, args?: OperationArgs, options?: CallOptions): Promise<T>;
+    /** Send one operation and return the raw `Response` (bytes, custom parsing). */
+    send(op: OperationDescriptor, args?: OperationArgs, options?: CallOptions): Promise<{
+        response: Response;
+        requestId: string;
+        controller: AbortController;
+    }>;
+    /** Resolve where an operation goes, without sending it. */
+    url(op: OperationDescriptor, args?: OperationArgs): string;
+}
+/** Build the one client. */
+declare function createApi(options?: CreateApiOptions): Api;
+/** Send a streaming operation and parse it per its contract stream kind. */
+declare function openStream<E>(api: Api, op: OperationDescriptor, args?: OperationArgs, options?: CallOptions): Promise<ApiStream<E>>;
+/** Send a conditional (`*_or_json`) operation: JSON when the server answered JSON, else the stream. */
+declare function openJsonOrStream<J, E>(api: Api, op: OperationDescriptor, args?: OperationArgs, options?: CallOptions): Promise<JsonOrStream<J, E>>;
+
+export { type Api as A, readMatrxSseStream as B, type CallOptions as C, DEPLOYMENTS as D, type Environment as E, type HttpMethod as H, type JsonOrStream as J, type MatrxStreamEnvelope as M, type NdjsonEvent as N, type OperationArgs as O, type ReadMatrxNdjsonOptions as R, type SseEvent as S, type ApiStream as a, type MatrxNdjsonIssue as b, type MatrxStreamEnvelopeObservation as c, type MatrxSseFrame as d, type ApiRequestInfo as e, type AuthTier as f, CONTRACT_SHA256 as g, type CreateApiOptions as h, DOMAINS as i, type DeploymentName as j, type OperationDescriptor as k, type OrgRule as l, type StreamKind as m, createApi as n, openJsonOrStream as o, openStream as p, DEFAULT_MATRX_NDJSON_READ_AHEAD as q, type MatrxNdjsonFramer as r, type MatrxNdjsonFramerOptions as s, type MatrxSseFramer as t, type ReadMatrxSseOptions as u, createMatrxNdjsonFramer as v, createMatrxSseFramer as w, normalizeMatrxStreamEnvelope as x, parseMatrxSseFrame as y, readMatrxNdjsonStream as z };