@clinia/context-engine-js 0.5.0-rc.0

package/dist/generated/types.d.ts

@@ -0,0 +1,26 @@
+import type { components } from "./context-engine";
+export type ServiceInfo = components["schemas"]["ServiceInfo"];
+export type PatientList = components["schemas"]["PatientList"];
+export type PatientDetail = components["schemas"]["PatientDetail"];
+export type ApiError = components["schemas"]["ApiError"];
+export type Patient = components["schemas"]["Patient"];
+export type ResolutionReport = components["schemas"]["ResolutionReport"];
+export type ReconciliationData = components["schemas"]["ReconciliationData"];
+export type IngestExecutionEnvelope = components["schemas"]["IngestExecutionEnvelope"];
+export type IngestExecutionStatus = components["schemas"]["IngestExecutionStatus"];
+export type IngestSourceLabel = components["schemas"]["IngestSourceLabel"];
+export type PatientRef = components["schemas"]["PatientRef"];
+export type IngestDocumentBody = components["schemas"]["IngestDocumentBody"];
+export type IngestBatchBody = components["schemas"]["IngestBatchBody"];
+export type IngestStatusResponse = components["schemas"]["IngestStatusResponse"];
+export type IngestStats = components["schemas"]["IngestStats"];
+export type IngestExecutionList = components["schemas"]["IngestExecutionList"];
+export type IngestExecutionListItem = components["schemas"]["IngestExecutionListItem"];
+export type IngestExecutionDetail = components["schemas"]["IngestExecutionDetail"];
+export type Session = components["schemas"]["Session"];
+export type AppendMessagesBody = components["schemas"]["AppendMessagesBody"];
+export type SessionMemoryList = components["schemas"]["SessionMemoryList"];
+export type SessionMemory = components["schemas"]["SessionMemory"];
+export type IngestSessionBody = components["schemas"]["IngestSessionBody"];
+export type BrowseResult = components["schemas"]["BrowseResult"];
+export type ReadResponse = components["schemas"]["ReadResponse"];

package/dist/http-client.d.ts

@@ -0,0 +1,40 @@
+import { type Client, type Middleware } from "openapi-fetch";
+import { type ClientCredentialsConfig } from "./auth";
+import type { paths } from "./generated/context-engine";
+export type HttpClientOptions = {
+    baseUrl: string;
+    /**
+     * Custom fetch implementation. Defaults to `globalThis.fetch`.
+     * Works in Node 20+ and all modern browsers out of the box.
+     * Useful for injecting a mock or a custom fetch in tests.
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * How to authenticate against a secured Context Engine server. Accepts either
+     * shape:
+     *
+     * - A {@link ClientCredentialsConfig} — the common case. Pass just your OAuth2
+     *   client credentials and the client sets up token acquisition, caching, and
+     *   refresh for you.
+     * - A token function `() => string | Promise<string>` — the escape hatch for
+     *   full control (a token from elsewhere, a different grant, or a custom
+     *   refresh strategy). Called per request, so a provider can cache and refresh
+     *   internally (e.g. {@link createClientCredentialsTokenProvider}); a falsy
+     *   return value leaves the header unset.
+     *
+     * Either way the resolved token is attached as `Authorization: Bearer <token>`
+     * on every request. Omit for an unsecured server.
+     */
+    auth?: ClientCredentialsConfig | (() => string | Promise<string>);
+};
+export declare class HttpClient {
+    #private;
+    constructor(options: HttpClientOptions);
+    get GET(): Client<paths>["GET"];
+    get POST(): Client<paths>["POST"];
+    get PUT(): Client<paths>["PUT"];
+    get PATCH(): Client<paths>["PATCH"];
+    get DELETE(): Client<paths>["DELETE"];
+    use(...middleware: Middleware[]): this;
+    eject(...middleware: Middleware[]): this;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./auth";
+export * from "./generated/context-engine";
+export * from "./generated/types";
+export * from "./http-client";
+export * from "./context-engine-client";

package/dist/index.js

@@ -0,0 +1,164 @@
+// src/auth.ts
+import * as oauth from "oauth4webapi";
+var CLINIA_OAUTH_TOKEN_URL = "https://console.clinia.cloud/api/auth/oauth2/token";
+var CLINIA_OAUTH_RESOURCE = "https://console.clinia.cloud";
+var DEFAULT_EXPIRY_MARGIN_MS = 6e4;
+var DEFAULT_TTL_MS = 5 * 6e4;
+function describeOAuthError(err) {
+  if (err instanceof oauth.ResponseBodyError) {
+    return `${err.status} ${err.error}${err.error_description ? ` \u2014 ${err.error_description}` : ""}`;
+  }
+  if (err instanceof oauth.WWWAuthenticateChallengeError) {
+    return `${err.status} ${err.message}`;
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+function createClientCredentialsTokenProvider(config) {
+  const expiryMarginMs = config.expiryMarginMs ?? DEFAULT_EXPIRY_MARGIN_MS;
+  const usesCliniaAuthServer = !config.tokenUrl && !config.issuer;
+  const resource = config.resource ?? (usesCliniaAuthServer ? CLINIA_OAUTH_RESOURCE : void 0);
+  const client = { client_id: config.clientId };
+  const clientAuth = config.authMethod === "basic" ? oauth.ClientSecretBasic(config.clientSecret) : oauth.ClientSecretPost(config.clientSecret);
+  const fetchImpl = config.fetch;
+  const isInsecure = (url) => !!url && new URL(url).protocol === "http:";
+  function withHttpOptions(opts, insecure) {
+    const o = opts;
+    if (fetchImpl) {
+      o[oauth.customFetch] = ((url, options) => fetchImpl(url, options));
+    }
+    if (insecure) o[oauth.allowInsecureRequests] = true;
+    return o;
+  }
+  let resolvedAs = null;
+  let asInFlight = null;
+  async function resolveAuthServer() {
+    if (!config.issuer || config.tokenUrl) {
+      const tokenUrl = config.tokenUrl ?? CLINIA_OAUTH_TOKEN_URL;
+      return {
+        issuer: config.issuer ?? new URL(tokenUrl).origin,
+        token_endpoint: tokenUrl
+      };
+    }
+    const issuerUrl = new URL(config.issuer);
+    const response = await oauth.discoveryRequest(
+      issuerUrl,
+      withHttpOptions(
+        { algorithm: config.discoveryAlgorithm ?? "oidc" },
+        isInsecure(config.issuer)
+      )
+    );
+    return oauth.processDiscoveryResponse(issuerUrl, response);
+  }
+  function getAuthServer() {
+    if (resolvedAs) return Promise.resolve(resolvedAs);
+    if (!asInFlight) {
+      asInFlight = resolveAuthServer().then((as) => resolvedAs = as).finally(() => {
+        asInFlight = null;
+      });
+    }
+    return asInFlight;
+  }
+  let cachedToken = null;
+  let expiresAt = 0;
+  let inFlight = null;
+  async function fetchToken() {
+    const params = new URLSearchParams();
+    if (resource) params.set("resource", resource);
+    if (config.audience) params.set("audience", config.audience);
+    if (config.scope) params.set("scope", config.scope);
+    let result;
+    try {
+      const as = await getAuthServer();
+      const response = await oauth.clientCredentialsGrantRequest(
+        as,
+        client,
+        clientAuth,
+        params,
+        withHttpOptions(
+          {},
+          isInsecure(as.token_endpoint)
+        )
+      );
+      result = await oauth.processClientCredentialsResponse(as, client, response);
+    } catch (err) {
+      throw new Error(`client_credentials token request failed: ${describeOAuthError(err)}`, {
+        cause: err
+      });
+    }
+    const ttlMs = result.expires_in ? result.expires_in * 1e3 : DEFAULT_TTL_MS;
+    cachedToken = result.access_token;
+    expiresAt = Date.now() + Math.max(0, ttlMs - expiryMarginMs);
+    return cachedToken;
+  }
+  return async function getAccessToken() {
+    if (cachedToken && Date.now() < expiresAt) return cachedToken;
+    if (inFlight) return inFlight;
+    inFlight = fetchToken().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+}
+
+// src/http-client.ts
+import createFetchClient from "openapi-fetch";
+var HttpClient = class {
+  #client;
+  constructor(options) {
+    this.#client = createFetchClient({
+      baseUrl: options.baseUrl,
+      fetch: options.fetch
+    });
+    const getAccessToken = typeof options.auth === "function" ? options.auth : options.auth ? createClientCredentialsTokenProvider({ fetch: options.fetch, ...options.auth }) : void 0;
+    if (getAccessToken) {
+      const authMiddleware = {
+        async onRequest({ request }) {
+          const token = await getAccessToken();
+          if (token) request.headers.set("Authorization", `Bearer ${token}`);
+          return request;
+        }
+      };
+      this.#client.use(authMiddleware);
+    }
+  }
+  get GET() {
+    return this.#client.GET;
+  }
+  get POST() {
+    return this.#client.POST;
+  }
+  get PUT() {
+    return this.#client.PUT;
+  }
+  get PATCH() {
+    return this.#client.PATCH;
+  }
+  get DELETE() {
+    return this.#client.DELETE;
+  }
+  use(...middleware) {
+    this.#client.use(...middleware);
+    return this;
+  }
+  eject(...middleware) {
+    this.#client.eject(...middleware);
+    return this;
+  }
+};
+
+// src/context-engine-client.ts
+var ContextEngineClient = class {
+  /**
+   * Low-level http client. Use when a resource method does not cover your use case.
+   */
+  http;
+  constructor(options) {
+    this.http = new HttpClient(options);
+  }
+};
+export {
+  ContextEngineClient,
+  HttpClient,
+  createClientCredentialsTokenProvider
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auth.ts","../src/http-client.ts","../src/context-engine-client.ts"],"sourcesContent":["import * as oauth from \"oauth4webapi\";\n\n/**\n * OAuth2 client-credentials helpers for authenticating against a secured\n * Context Engine workspace.\n *\n * The server validates a bearer JWT in the `Authorization` header against a\n * JWKS. This module provides the client half: a token provider that exchanges\n * a `client_id`/`client_secret` for an access token, caches it, and refreshes\n * it before expiry. The token exchange itself is delegated to `oauth4webapi`\n * (standards-compliant request building + response validation); this module\n * only adds caching, concurrent-request de-duplication, and a small config\n * surface. Pass the raw config as {@link HttpClientOptions.auth}, or — for full\n * control — pass the returned provider as the {@link HttpClientOptions.auth}\n * token function.\n */\n\n/**\n * Resolves to a currently-valid bearer access token. Called per request; a\n * well-behaved provider caches internally and only hits the network when the\n * cached token is missing or about to expire.\n */\nexport type TokenProvider = () => Promise<string>;\n\n/**\n * Clinia's authorization server, applied when a config names neither a\n * `tokenUrl` nor an `issuer` — so `{ clientId, clientSecret }` is a complete\n * config for a Clinia workspace, which is the overwhelmingly common case.\n *\n * `RESOURCE` is only defaulted alongside `TOKEN_URL`: it is an RFC 8707\n * indicator naming Clinia's protected resource, and sending it to somebody\n * else's authorization server would be wrong.\n */\nconst CLINIA_OAUTH_TOKEN_URL = \"https://console.clinia.cloud/api/auth/oauth2/token\";\nconst CLINIA_OAUTH_RESOURCE = \"https://console.clinia.cloud\";\n\n/** Fields common to both ways of locating the authorization server. */\ntype ClientCredentialsBase = {\n  clientId: string;\n  clientSecret: string;\n  /**\n   * Optional `resource` indicator (RFC 8707) naming the protected resource the\n   * token is for. This is what the Clinia authorization server expects (e.g.\n   * `https://console.clinia.cloud`).\n   */\n  resource?: string;\n  /** Optional `audience` parameter (used by some IdPs, e.g. Auth0). */\n  audience?: string;\n  /** Optional space-delimited `scope`. */\n  scope?: string;\n  /**\n   * How the client credentials are presented to the token endpoint. `post`\n   * (the default) sends them in the request body — what the Clinia\n   * authorization server expects; `basic` sends them in the `Authorization`\n   * header (RFC 6749 §2.3.1) for IdPs that require it.\n   */\n  authMethod?: \"basic\" | \"post\";\n  /**\n   * Custom fetch implementation. Defaults to `globalThis.fetch`. Useful for\n   * injecting a mock in tests.\n   */\n  fetch?: typeof globalThis.fetch;\n  /**\n   * Refresh the token this many milliseconds before it actually expires, to\n   * avoid handing out a token that expires mid-flight. Defaults to 60_000.\n   */\n  expiryMarginMs?: number;\n};\n\n/**\n * Client-credentials configuration.\n *\n * For a Clinia workspace, `{ clientId, clientSecret }` is enough — the token\n * endpoint and `resource` indicator default to Clinia's authorization server.\n * Naming an {@link issuer} instead locates a different authorization server by\n * OIDC/OAuth2 discovery; naming a {@link tokenUrl} points at one explicitly.\n */\nexport type ClientCredentialsConfig =\n  | (ClientCredentialsBase & {\n      /**\n       * Issuer identifier of the authorization server. Its metadata (token\n       * endpoint, etc.) is resolved via discovery on first use.\n       */\n      issuer: string;\n      /** Discovery transformation: `oidc` (default) or `oauth2` (RFC 8414). */\n      discoveryAlgorithm?: \"oidc\" | \"oauth2\";\n      tokenUrl?: never;\n    })\n  | (ClientCredentialsBase & {\n      /**\n       * Explicit OAuth2 token endpoint; discovery is skipped. Omit it — along\n       * with `issuer` — to use Clinia's.\n       */\n      tokenUrl?: string;\n      /** Issuer identifier for response validation; defaults to the token URL's origin. */\n      issuer?: string;\n      discoveryAlgorithm?: never;\n    });\n\nconst DEFAULT_EXPIRY_MARGIN_MS = 60_000;\n/** Fallback lifetime when the token endpoint omits `expires_in`. */\nconst DEFAULT_TTL_MS = 5 * 60_000;\n\n/** Turns an `oauth4webapi` failure into a concise, stable error message. */\nfunction describeOAuthError(err: unknown): string {\n  if (err instanceof oauth.ResponseBodyError) {\n    return `${err.status} ${err.error}${err.error_description ? ` — ${err.error_description}` : \"\"}`;\n  }\n  if (err instanceof oauth.WWWAuthenticateChallengeError) {\n    return `${err.status} ${err.message}`;\n  }\n  return err instanceof Error ? err.message : String(err);\n}\n\n/**\n * Builds a {@link TokenProvider} backed by the OAuth2 client-credentials grant.\n *\n * The provider caches the access token and reuses it until it is within\n * `expiryMarginMs` of expiry. Concurrent calls while a fetch is in flight share\n * the same request rather than each hitting the token endpoint. When configured\n * with an {@link ClientCredentialsConfig.issuer}, the authorization server\n * metadata is discovered once and memoized.\n */\nexport function createClientCredentialsTokenProvider(\n  config: ClientCredentialsConfig,\n): TokenProvider {\n  const expiryMarginMs = config.expiryMarginMs ?? DEFAULT_EXPIRY_MARGIN_MS;\n\n  // Defaulted only when the token endpoint is also defaulted. `resource` names\n  // Clinia's protected resource, so attaching it to a request aimed at somebody\n  // else's authorization server would be both wrong and a small disclosure.\n  const usesCliniaAuthServer = !config.tokenUrl && !config.issuer;\n  const resource = config.resource ?? (usesCliniaAuthServer ? CLINIA_OAUTH_RESOURCE : undefined);\n\n  const client: oauth.Client = { client_id: config.clientId };\n  const clientAuth =\n    config.authMethod === \"basic\"\n      ? oauth.ClientSecretBasic(config.clientSecret)\n      : oauth.ClientSecretPost(config.clientSecret);\n\n  // Shared HTTP options (custom fetch + insecure opt-in) applied to every\n  // oauth4webapi call. The `as never` bridges the customFetch signature, which\n  // is generic over method/body per call site but is the same fn at runtime.\n  // oauth4webapi rejects non-TLS endpoints by default; we relax that per call\n  // when — and only when — the target URL is itself `http://` (local dev),\n  // rather than exposing a separate flag.\n  const fetchImpl = config.fetch;\n  const isInsecure = (url: string | undefined): boolean =>\n    !!url && new URL(url).protocol === \"http:\";\n  function withHttpOptions<T extends object>(opts: T, insecure: boolean): T {\n    const o = opts as T & {\n      [oauth.customFetch]?: unknown;\n      [oauth.allowInsecureRequests]?: boolean;\n    };\n    if (fetchImpl) {\n      o[oauth.customFetch] = ((url: string, options: RequestInit) =>\n        fetchImpl(url, options)) as never;\n    }\n    if (insecure) o[oauth.allowInsecureRequests] = true;\n    return o;\n  }\n\n  // Authorization server metadata, resolved once. For an explicit tokenUrl it's\n  // synchronous; for an issuer it requires a discovery request, so it's async\n  // and memoized (with retry on failure — a rejected attempt isn't cached).\n  let resolvedAs: oauth.AuthorizationServer | null = null;\n  let asInFlight: Promise<oauth.AuthorizationServer> | null = null;\n\n  async function resolveAuthServer(): Promise<oauth.AuthorizationServer> {\n    // Discovery only when an issuer is named and no explicit endpoint overrides\n    // it. There is no \"neither given\" case left to handle — that is the Clinia\n    // default, which is why this no longer throws.\n    if (!config.issuer || config.tokenUrl) {\n      const tokenUrl = config.tokenUrl ?? CLINIA_OAUTH_TOKEN_URL;\n      return {\n        issuer: config.issuer ?? new URL(tokenUrl).origin,\n        token_endpoint: tokenUrl,\n      };\n    }\n    const issuerUrl = new URL(config.issuer);\n    const response = await oauth.discoveryRequest(\n      issuerUrl,\n      withHttpOptions<oauth.DiscoveryRequestOptions>(\n        { algorithm: config.discoveryAlgorithm ?? \"oidc\" },\n        isInsecure(config.issuer),\n      ),\n    );\n    return oauth.processDiscoveryResponse(issuerUrl, response);\n  }\n\n  function getAuthServer(): Promise<oauth.AuthorizationServer> {\n    if (resolvedAs) return Promise.resolve(resolvedAs);\n    if (!asInFlight) {\n      asInFlight = resolveAuthServer()\n        .then((as) => (resolvedAs = as))\n        .finally(() => {\n          asInFlight = null;\n        });\n    }\n    return asInFlight;\n  }\n\n  let cachedToken: string | null = null;\n  /** Absolute epoch ms at which the cached token should be considered stale. */\n  let expiresAt = 0;\n  /** In-flight fetch, shared across concurrent callers to dedupe requests. */\n  let inFlight: Promise<string> | null = null;\n\n  async function fetchToken(): Promise<string> {\n    const params = new URLSearchParams();\n    if (resource) params.set(\"resource\", resource);\n    if (config.audience) params.set(\"audience\", config.audience);\n    if (config.scope) params.set(\"scope\", config.scope);\n\n    let result: oauth.TokenEndpointResponse;\n    try {\n      const as = await getAuthServer();\n      const response = await oauth.clientCredentialsGrantRequest(\n        as,\n        client,\n        clientAuth,\n        params,\n        withHttpOptions<oauth.ClientCredentialsGrantRequestOptions>(\n          {},\n          isInsecure(as.token_endpoint),\n        ),\n      );\n      result = await oauth.processClientCredentialsResponse(as, client, response);\n    } catch (err) {\n      throw new Error(`client_credentials token request failed: ${describeOAuthError(err)}`, {\n        cause: err,\n      });\n    }\n\n    const ttlMs = result.expires_in ? result.expires_in * 1000 : DEFAULT_TTL_MS;\n    cachedToken = result.access_token;\n    expiresAt = Date.now() + Math.max(0, ttlMs - expiryMarginMs);\n    return cachedToken;\n  }\n\n  return async function getAccessToken(): Promise<string> {\n    if (cachedToken && Date.now() < expiresAt) return cachedToken;\n    if (inFlight) return inFlight;\n\n    inFlight = fetchToken().finally(() => {\n      inFlight = null;\n    });\n    return inFlight;\n  };\n}\n","import createFetchClient, { type Client, type Middleware } from \"openapi-fetch\";\n\nimport { createClientCredentialsTokenProvider, type ClientCredentialsConfig } from \"./auth\";\nimport type { paths } from \"./generated/context-engine\";\n\nexport type HttpClientOptions = {\n  baseUrl: string;\n  /**\n   * Custom fetch implementation. Defaults to `globalThis.fetch`.\n   * Works in Node 20+ and all modern browsers out of the box.\n   * Useful for injecting a mock or a custom fetch in tests.\n   */\n  fetch?: typeof globalThis.fetch;\n  /**\n   * How to authenticate against a secured Context Engine server. Accepts either\n   * shape:\n   *\n   * - A {@link ClientCredentialsConfig} — the common case. Pass just your OAuth2\n   *   client credentials and the client sets up token acquisition, caching, and\n   *   refresh for you.\n   * - A token function `() => string | Promise<string>` — the escape hatch for\n   *   full control (a token from elsewhere, a different grant, or a custom\n   *   refresh strategy). Called per request, so a provider can cache and refresh\n   *   internally (e.g. {@link createClientCredentialsTokenProvider}); a falsy\n   *   return value leaves the header unset.\n   *\n   * Either way the resolved token is attached as `Authorization: Bearer <token>`\n   * on every request. Omit for an unsecured server.\n   */\n  auth?: ClientCredentialsConfig | (() => string | Promise<string>);\n};\n\nexport class HttpClient {\n  readonly #client: Client<paths>;\n\n  constructor(options: HttpClientOptions) {\n    this.#client = createFetchClient<paths>({\n      baseUrl: options.baseUrl,\n      fetch: options.fetch,\n    });\n\n    // A token function is used as-is; a config object builds a client-credentials\n    // provider. The custom `fetch` is threaded into the token exchange too so\n    // tests/proxies apply to both hops.\n    const getAccessToken =\n      typeof options.auth === \"function\"\n        ? options.auth\n        : options.auth\n          ? createClientCredentialsTokenProvider({ fetch: options.fetch, ...options.auth })\n          : undefined;\n\n    if (getAccessToken) {\n      const authMiddleware: Middleware = {\n        async onRequest({ request }) {\n          const token = await getAccessToken();\n          if (token) request.headers.set(\"Authorization\", `Bearer ${token}`);\n          return request;\n        },\n      };\n      this.#client.use(authMiddleware);\n    }\n  }\n\n  get GET(): Client<paths>[\"GET\"] {\n    return this.#client.GET;\n  }\n\n  get POST(): Client<paths>[\"POST\"] {\n    return this.#client.POST;\n  }\n\n  get PUT(): Client<paths>[\"PUT\"] {\n    return this.#client.PUT;\n  }\n\n  get PATCH(): Client<paths>[\"PATCH\"] {\n    return this.#client.PATCH;\n  }\n\n  get DELETE(): Client<paths>[\"DELETE\"] {\n    return this.#client.DELETE;\n  }\n\n  use(...middleware: Middleware[]): this {\n    this.#client.use(...middleware);\n    return this;\n  }\n\n  eject(...middleware: Middleware[]): this {\n    this.#client.eject(...middleware);\n    return this;\n  }\n}\n","import { HttpClient, type HttpClientOptions } from \"./http-client\";\n\nexport type ContextEngineClientOptions = HttpClientOptions;\n\n/**\n * Client for the Clinia Context Engine API.\n *\n * For now this client only exposes a low-level `http` client for making requests to the API. Higher-level resource methods can be added as the API surface stabilizes.\n */\nexport class ContextEngineClient {\n  /**\n   * Low-level http client. Use when a resource method does not cover your use case.\n   */\n  readonly http: HttpClient;\n\n  constructor(options: ContextEngineClientOptions) {\n    this.http = new HttpClient(options);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/resources/index.d.ts

@@ -0,0 +1,5 @@
+export { InfoResource } from "./info";
+export { PatientsResource } from "./patients";
+export { IngestResource } from "./ingest";
+export { SessionsResource } from "./sessions";
+export { VFSResource } from "./vfs";

package/dist/resources/info.d.ts

@@ -0,0 +1,24 @@
+import type { HttpClient } from "../http-client";
+export declare class InfoResource {
+    #private;
+    constructor(http: HttpClient);
+    getServiceInfo(): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ServiceInfo"];
+                };
+            };
+        };
+    }, undefined, `${string}/${string}`>>;
+}

package/dist/resources/ingest.d.ts

@@ -0,0 +1,323 @@
+import type { HttpClient } from "../http-client";
+import type { operations } from "../generated/context-engine";
+import type { IngestDocumentBody, IngestBatchBody } from "../generated/types";
+export declare class IngestResource {
+    #private;
+    constructor(http: HttpClient);
+    listExecutions(patientId: string, params?: {
+        query?: {
+            limit?: number;
+            cursor?: number;
+        };
+    }): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                limit?: number;
+                cursor?: number | null;
+            };
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionList"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query?: {
+                limit?: number;
+                cursor?: number;
+            } | undefined;
+            path: {
+                patientId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    getIngestStatus(patientId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestStatusResponse"];
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                patientId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    getExecution(patientId: string, executionId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                patientId: string;
+                executionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionDetail"];
+                };
+            };
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ApiError"];
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                patientId: string;
+                executionId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    ingestFhir(patientId: string, body: NonNullable<operations["ingest-fhir"]["requestBody"]>["content"]["application/json"], params?: {
+        query?: {
+            wait?: number;
+        };
+    }): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                wait?: number | null;
+            };
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    [key: string]: unknown;
+                };
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionEnvelope"];
+                };
+            };
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ApiError"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query?: {
+                wait?: number;
+            } | undefined;
+            path: {
+                patientId: string;
+            };
+        };
+        body: {
+            [key: string]: unknown;
+        };
+    }, `${string}/${string}`>>;
+    ingestCda(patientId: string, body: NonNullable<operations["ingest-cda"]["requestBody"]>["content"]["text/plain"], params?: {
+        query?: {
+            wait?: number;
+        };
+    }): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                wait?: number | null;
+            };
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "text/plain": string;
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionEnvelope"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ApiError"];
+                };
+            };
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ApiError"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query?: {
+                wait?: number;
+            } | undefined;
+            path: {
+                patientId: string;
+            };
+        };
+        body: string;
+        bodySerializer: (b: BodyInit) => BodyInit;
+        headers: {
+            "Content-Type": string;
+        };
+    }, `${string}/${string}`>>;
+    ingestDocument(patientId: string, body: IngestDocumentBody, params?: {
+        query?: {
+            wait?: number;
+        };
+    }): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                wait?: number | null;
+            };
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": import("..").components["schemas"]["IngestDocumentBody"];
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionEnvelope"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query?: {
+                wait?: number;
+            } | undefined;
+            path: {
+                patientId: string;
+            };
+        };
+        body: {
+            name: string;
+            mimeType?: string;
+        };
+    }, `${string}/${string}`>>;
+    ingestBatch(patientId: string, body: IngestBatchBody, params?: {
+        query?: {
+            wait?: number;
+        };
+    }): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                wait?: number | null;
+            };
+            header?: never;
+            path: {
+                patientId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": import("..").components["schemas"]["IngestBatchBody"];
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["IngestExecutionEnvelope"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("..").components["schemas"]["ApiError"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query?: {
+                wait?: number;
+            } | undefined;
+            path: {
+                patientId: string;
+            };
+        };
+        body: {
+            fhir?: {
+                [key: string]: unknown;
+            }[];
+            cda?: string[];
+            documents?: import("..").components["schemas"]["IngestDocumentBody"][];
+        };
+    }, `${string}/${string}`>>;
+}