@astermd-hq/sdk 0.0.2

package/dist/index.cjs

@@ -0,0 +1,3338 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var crypto = require('crypto');
+
+// src/auth/in-memory-token-store.ts
+var InMemoryTokenStore = class {
+  #token = null;
+  /**
+   * Returns the token held in memory, or `null` before the first exchange.
+   *
+   * @returns The cached token, or `null`.
+   */
+  get() {
+    return Promise.resolve(this.#token);
+  }
+  /**
+   * Replaces the token held in memory.
+   *
+   * @param token The token to cache.
+   */
+  put(token) {
+    this.#token = token;
+    return Promise.resolve();
+  }
+  /**
+   * Drops the token held in memory.
+   */
+  clear() {
+    this.#token = null;
+    return Promise.resolve();
+  }
+};
+
+// src/errors/astermd-error.ts
+var AsterMDError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "AsterMDError";
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+};
+
+// src/errors/api-error.ts
+var ApiError = class extends AsterMDError {
+  #statusCode;
+  #envelope;
+  /**
+   * @param message Human-readable message, taken from the envelope's `message`
+   *                field when the server sent one, otherwise `HTTP {status}`.
+   * @param statusCode The HTTP status code the server returned.
+   * @param envelope The decoded response body. Copied and frozen, so a later
+   *                 mutation of the caller's object cannot change the error.
+   */
+  constructor(message, statusCode, envelope) {
+    super(message);
+    this.name = "ApiError";
+    this.#statusCode = statusCode;
+    this.#envelope = Object.freeze({ ...envelope });
+  }
+  /**
+   * Returns the HTTP status code that caused this error.
+   *
+   * @returns The status code, e.g. `404` or `500`.
+   */
+  statusCode() {
+    return this.#statusCode;
+  }
+  /**
+   * Returns the decoded response envelope as the server sent it.
+   *
+   * Useful for surfacing a server-supplied message or an error code the SDK does
+   * not model. The object is frozen; treat it as read-only.
+   *
+   * @returns The decoded body, or an empty object when the response had none.
+   */
+  envelope() {
+    return this.#envelope;
+  }
+};
+
+// src/errors/authentication-error.ts
+var AuthenticationError = class extends ApiError {
+  constructor(message, statusCode, envelope) {
+    super(message, statusCode, envelope);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/errors/not-found-error.ts
+var NotFoundError = class extends ApiError {
+  constructor(message, statusCode, envelope) {
+    super(message, statusCode, envelope);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/errors/rate-limit-error.ts
+var RateLimitError = class extends ApiError {
+  #retryAfter;
+  /**
+   * @param message Human-readable summary from the envelope.
+   * @param statusCode Always 429 in practice.
+   * @param envelope The decoded response body.
+   * @param retryAfter Seconds to wait, from the `Retry-After` header, or `null`
+   *                   when the header was absent or not a plain integer.
+   */
+  constructor(message, statusCode, envelope, retryAfter2) {
+    super(message, statusCode, envelope);
+    this.name = "RateLimitError";
+    this.#retryAfter = retryAfter2;
+  }
+  /**
+   * Returns the server-advised wait in seconds before retrying.
+   *
+   * @returns Seconds to wait, or `null` when the server did not say.
+   */
+  retryAfter() {
+    return this.#retryAfter;
+  }
+};
+
+// src/errors/transport-error.ts
+var TransportError = class extends AsterMDError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TransportError";
+  }
+};
+
+// src/errors/validation-error.ts
+var ValidationError = class extends ApiError {
+  #fieldErrors;
+  /**
+   * @param message Human-readable summary from the envelope.
+   * @param statusCode Always 422 in practice.
+   * @param envelope The decoded response body.
+   * @param fieldErrors Field name → list of messages, extracted from the
+   *                    envelope's `errors` key by {@link Transport}.
+   */
+  constructor(message, statusCode, envelope, fieldErrors2) {
+    super(message, statusCode, envelope);
+    this.name = "ValidationError";
+    this.#fieldErrors = Object.freeze({ ...fieldErrors2 });
+  }
+  /**
+   * Returns the per-field validation messages the server produced.
+   *
+   * @returns Field name → messages. Empty when the server sent no `errors` key.
+   */
+  fieldErrors() {
+    return this.#fieldErrors;
+  }
+};
+
+// src/response.ts
+var Response2 = class {
+  #statusCode;
+  #data;
+  #meta;
+  #message;
+  #raw;
+  /**
+   * @param options The decoded envelope fields.
+   */
+  constructor(options) {
+    this.#statusCode = options.statusCode;
+    this.#data = Object.freeze(Array.isArray(options.data) ? [...options.data] : { ...options.data });
+    this.#meta = Object.freeze({ ...options.meta });
+    this.#message = options.message;
+    this.#raw = options.raw;
+    Object.freeze(this);
+  }
+  /**
+   * Returns the HTTP status code, always 200–299 for a `Response` instance.
+   *
+   * @returns The status code, e.g. `200` or `201`.
+   */
+  statusCode() {
+    return this.#statusCode;
+  }
+  /**
+   * Returns the primary resource payload from the envelope's `data` key.
+   *
+   * The shape varies by endpoint - see the TSDoc on the resource method you
+   * called. Empty when the server returned no data.
+   *
+   * @returns The decoded `data` object.
+   */
+  data() {
+    return this.#data;
+  }
+  /**
+   * Returns the envelope's `meta` key, typically pagination information.
+   *
+   * Present on paginated list endpoints such as `products/list` and
+   * `treatments/list`, where it may carry `total`, `per_page`, `current_page`,
+   * and `last_page`. Empty for endpoints that emit no `meta` block.
+   *
+   * @returns The decoded `meta` object.
+   */
+  meta() {
+    return this.#meta;
+  }
+  /**
+   * Returns the human-readable `message` string from the envelope.
+   *
+   * Usually a short confirmation such as `"Session created."`. Empty when the
+   * server omitted the field.
+   *
+   * @returns The envelope message, possibly empty.
+   */
+  message() {
+    return this.#message;
+  }
+  /**
+   * Returns the raw response body exactly as received, before decoding.
+   *
+   * Useful for low-level debugging. Do not log this value for endpoints carrying
+   * PHI, such as `patients/health-information`.
+   *
+   * @returns The raw JSON body.
+   */
+  raw() {
+    return this.#raw;
+  }
+};
+
+// src/http/transport.ts
+var Transport = class {
+  #httpClient;
+  #urlBuilder;
+  #tokenProvider;
+  #onUnauthorized;
+  /**
+   * @param options The collaborators to use for every call.
+   */
+  constructor(options) {
+    this.#httpClient = options.httpClient;
+    this.#urlBuilder = options.urlBuilder;
+    this.#tokenProvider = options.tokenProvider;
+    this.#onUnauthorized = options.onUnauthorized;
+  }
+  /**
+   * Dispatches one API call and returns the decoded success envelope.
+   *
+   * On a 401 the token is refreshed and the call is replayed once before
+   * {@link AuthenticationError} is raised.
+   *
+   * @param options The call to make.
+   * @returns The decoded envelope; `data()` holds the resource payload.
+   * @throws {TypeError} If both `body` and `file` are supplied.
+   * @throws {AuthenticationError} On a 401 that a token refresh did not recover.
+   * @throws {NotFoundError} On a 404.
+   * @throws {ValidationError} On a 422; inspect `fieldErrors()`.
+   * @throws {RateLimitError} On a 429; inspect `retryAfter()`.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async send(options) {
+    if (options.body != null && options.file != null) {
+      throw new TypeError("A request carries either a JSON body or a file upload, not both.");
+    }
+    let response = await this.#dispatch(options);
+    if (response.status === 401 && await this.#onUnauthorized()) {
+      void response.body?.cancel();
+      response = await this.#dispatch(options);
+    }
+    return await this.#handle(response);
+  }
+  /**
+   * Builds and sends one attempt.
+   *
+   * A fresh `Request` is constructed on every call rather than reused across the
+   * 401 replay. A request body is a single-use stream: sending an already-sent
+   * `Request` again transmits an empty body, silently. Keeping the description
+   * and materialising the request per attempt is what makes the replay correct.
+   */
+  async #dispatch(options) {
+    const url = this.#urlBuilder.build(options.service, options.path, options.pathParams ?? {}, options.query ?? {});
+    const headers = new Headers({ Accept: "application/json" });
+    const token = await this.#tokenProvider();
+    if (token !== null) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+      headers.set(name, value);
+    }
+    let body = null;
+    if (options.body != null) {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(options.body);
+    } else if (options.file != null) {
+      const form = new FormData();
+      form.append(
+        "file",
+        new Blob([options.file.contents()], { type: options.file.mimeType() }),
+        options.file.fileName()
+      );
+      body = form;
+    }
+    try {
+      return await this.#httpClient.sendRequest(new Request(url, { method: options.method, headers, body }));
+    } catch (error) {
+      if (error instanceof AsterMDError) {
+        throw error;
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new TransportError(`Request to ${url} failed: ${detail}`, {
+        cause: error
+      });
+    }
+  }
+  async #handle(response) {
+    let raw;
+    try {
+      raw = await response.text();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new TransportError(`Reading the response body failed: ${detail}`, {
+        cause: error
+      });
+    }
+    const envelope = decode(raw);
+    const status = response.status;
+    if (status >= 200 && status < 300) {
+      return new Response2({
+        statusCode: status,
+        data: objectField(envelope, "data"),
+        meta: objectField(envelope, "meta"),
+        message: typeof envelope.message === "string" ? envelope.message : "",
+        raw
+      });
+    }
+    const message = typeof envelope.message === "string" ? envelope.message : `HTTP ${status}`;
+    switch (status) {
+      case 401:
+        throw new AuthenticationError(message, status, envelope);
+      case 404:
+        throw new NotFoundError(message, status, envelope);
+      case 422:
+        throw new ValidationError(message, status, envelope, fieldErrors(envelope));
+      case 429:
+        throw new RateLimitError(message, status, envelope, retryAfter(response));
+      default:
+        throw new ApiError(message, status, envelope);
+    }
+  }
+};
+function decode(raw) {
+  if (raw === "") {
+    return {};
+  }
+  try {
+    const decoded = JSON.parse(raw);
+    return typeof decoded === "object" && decoded !== null ? decoded : {};
+  } catch {
+    return {};
+  }
+}
+function objectField(envelope, key) {
+  const value = envelope[key];
+  return typeof value === "object" && value !== null ? value : {};
+}
+function fieldErrors(envelope) {
+  const errors = envelope.errors;
+  if (typeof errors !== "object" || errors === null || Array.isArray(errors)) {
+    return {};
+  }
+  const out = {};
+  for (const [field, messages] of Object.entries(errors)) {
+    if (Array.isArray(messages)) {
+      out[field] = messages.filter((message) => typeof message === "string");
+    } else if (typeof messages === "string") {
+      out[field] = [messages];
+    } else if (typeof messages === "object" && messages !== null) {
+      out[field] = Object.values(messages).filter((message) => typeof message === "string");
+    }
+  }
+  return out;
+}
+function retryAfter(response) {
+  const header = response.headers.get("Retry-After");
+  return header !== null && /^\d+$/.test(header) ? Number(header) : null;
+}
+
+// src/auth/token.ts
+var Token = class {
+  #value;
+  #expiresAtMs;
+  /**
+   * @param value The raw JWT string, to be sent as `Authorization: Bearer <value>`.
+   * @param expiresAt Expiry as declared by the token response's
+   *                  `access_token_expiry` field. Copied, so a later mutation of
+   *                  the caller's `Date` cannot change the token.
+   */
+  constructor(value, expiresAt) {
+    this.#value = value;
+    this.#expiresAtMs = expiresAt.getTime();
+    Object.freeze(this);
+  }
+  /**
+   * Returns the raw JWT string.
+   *
+   * @returns The JWT, ready for use as a bearer credential.
+   */
+  value() {
+    return this.#value;
+  }
+  /**
+   * Returns the server-stated expiry.
+   *
+   * A fresh `Date` each call, so callers cannot mutate the token's state. Note
+   * that the SDK treats the token as expired before this moment - see
+   * {@link Token.isExpired}.
+   *
+   * @returns The expiry as declared in the token response.
+   */
+  expiresAt() {
+    return new Date(this.#expiresAtMs);
+  }
+  /**
+   * Reports whether this token should be considered expired and replaced.
+   *
+   * The pre-buffer avoids a race where the token is valid when checked but
+   * expires in transit before the server processes the request. The default 30
+   * seconds means the SDK only trusts a token with at least half a minute of
+   * validity left. Pass a custom value only when you know something specific
+   * about clock skew in your environment.
+   *
+   * @param preBufferSeconds Seconds to subtract from the stated expiry when
+   *   computing the effective cutoff.
+   * @returns `true` when the token is at or past its effective expiry.
+   */
+  isExpired(preBufferSeconds = 30) {
+    return Date.now() >= this.#expiresAtMs - preBufferSeconds * 1e3;
+  }
+};
+
+// src/auth/token-manager.ts
+var TokenManager = class {
+  #config;
+  #store;
+  #expiryPreBufferSeconds;
+  #tokenTransport;
+  #inFlight = null;
+  /**
+   * @param options The collaborators and tuning to use.
+   */
+  constructor(options) {
+    this.#config = options.config;
+    this.#store = options.store ?? new InMemoryTokenStore();
+    this.#expiryPreBufferSeconds = options.expiryPreBufferSeconds ?? 30;
+    this.#tokenTransport = new Transport({
+      httpClient: options.httpClient,
+      urlBuilder: options.urlBuilder,
+      tokenProvider: () => Promise.resolve(null),
+      onUnauthorized: () => Promise.resolve(false)
+    });
+  }
+  /**
+   * Returns a valid bearer token, acquiring one if the cache cannot serve it.
+   *
+   * A cached, unexpired token is returned with no HTTP call. Otherwise the
+   * credential exchange runs and its result is stored before being returned. Two
+   * concurrent calls that both miss the cache share a single exchange.
+   *
+   * @returns The raw JWT, ready for `Authorization: Bearer <value>`.
+   * @throws {AuthenticationError} If the credentials are refused, or if the token
+   *   response omits `access_token` or `access_token_expiry`.
+   * @throws {TransportError} If the exchange never completed.
+   */
+  async bearerToken() {
+    const cached = await this.#store.get();
+    if (cached !== null && !cached.isExpired(this.#expiryPreBufferSeconds)) {
+      return cached.value();
+    }
+    return (await this.#acquire()).value();
+  }
+  /**
+   * Discards the cached token, acquires a fresh one, and reports `true`.
+   *
+   * Always resolves `true` on success so it can be wired straight to
+   * {@link Transport}'s `onUnauthorized` hook, where `true` means "token
+   * refreshed, replay the request once". A second 401 on that replay raises
+   * {@link AuthenticationError} without calling this again.
+   *
+   * @returns `true`.
+   * @throws {AuthenticationError} If the fresh acquisition fails.
+   * @throws {TransportError} If the exchange never completed.
+   */
+  async refresh() {
+    await this.#store.clear();
+    await this.#acquire();
+    return true;
+  }
+  /**
+   * Runs the credential exchange, sharing one in-flight attempt across callers.
+   *
+   * The in-flight promise is cleared in a `finally`, so a failed exchange is
+   * never cached - the next caller gets a fresh attempt rather than the stored
+   * rejection.
+   */
+  async #acquire() {
+    this.#inFlight ??= this.#exchange().finally(() => {
+      this.#inFlight = null;
+    });
+    return await this.#inFlight;
+  }
+  async #exchange() {
+    const response = await this.#tokenTransport.send({
+      service: "auth",
+      method: "POST",
+      path: "/api-credentials/token",
+      body: {
+        client_id: this.#config.clientId(),
+        client_secret: this.#config.clientSecret()
+      }
+    });
+    const data = response.data();
+    const value = data.access_token;
+    const expiry = data.access_token_expiry;
+    if (typeof value !== "string" || typeof expiry !== "string") {
+      throw new AuthenticationError(
+        "Token response missing access_token / access_token_expiry.",
+        response.statusCode(),
+        { data }
+      );
+    }
+    const expiresAt = new Date(expiry);
+    if (Number.isNaN(expiresAt.getTime())) {
+      throw new AuthenticationError(
+        `Token response carried an unparseable access_token_expiry: ${expiry}`,
+        response.statusCode(),
+        { data }
+      );
+    }
+    const token = new Token(value, expiresAt);
+    await this.#store.put(token);
+    return token;
+  }
+};
+
+// src/config.ts
+var ASSET_BASE_URL = "https://cdn.astermd.com/";
+var DEFAULT_BASE_HOST = "api.astermd.com";
+var Config = class {
+  #clientId;
+  #clientSecret;
+  #baseHost;
+  #timeoutSeconds;
+  /**
+   * @param options Credentials and connection settings.
+   * @throws {TypeError} If `clientId` or `clientSecret` is empty, if `baseHost`
+   *   contains a scheme or a path, or if `timeoutSeconds` is below 1.
+   */
+  constructor(options) {
+    const { clientId, clientSecret, baseHost = DEFAULT_BASE_HOST, timeoutSeconds = 10 } = options;
+    if (clientId === "" || clientSecret === "") {
+      throw new TypeError("clientId and clientSecret must be non-empty.");
+    }
+    if (baseHost.includes("://") || baseHost.includes("/")) {
+      throw new TypeError(`baseHost must be a bare host (no scheme, no path). Got: ${baseHost}`);
+    }
+    if (timeoutSeconds < 1) {
+      throw new TypeError("timeoutSeconds must be >= 1.");
+    }
+    this.#clientId = clientId;
+    this.#clientSecret = clientSecret;
+    this.#baseHost = baseHost;
+    this.#timeoutSeconds = timeoutSeconds;
+    Object.freeze(this);
+  }
+  /**
+   * Returns the OAuth2 client ID used to acquire JWT bearer tokens.
+   *
+   * @returns The client ID, guaranteed non-empty.
+   */
+  clientId() {
+    return this.#clientId;
+  }
+  /**
+   * Returns the OAuth2 client secret used to acquire JWT bearer tokens.
+   *
+   * @returns The client secret, guaranteed non-empty.
+   */
+  clientSecret() {
+    return this.#clientSecret;
+  }
+  /**
+   * Returns the bare API hostname used to build request URLs.
+   *
+   * Never contains a scheme or a path. {@link UrlBuilder} prepends `https://`
+   * and appends `/v1/{service}/{path}` at request time.
+   *
+   * @returns The hostname, e.g. `api.astermd.com`.
+   */
+  baseHost() {
+    return this.#baseHost;
+  }
+  /**
+   * Returns the per-request HTTP timeout in seconds.
+   *
+   * Applied by {@link FetchHttpClient} as an `AbortSignal` deadline covering the
+   * whole request. A custom {@link HttpClient} may use it at its own discretion.
+   *
+   * @returns The timeout in seconds, always >= 1.
+   */
+  timeoutSeconds() {
+    return this.#timeoutSeconds;
+  }
+  /**
+   * Builds the fully-qualified CDN URL for a media asset path returned by the API.
+   *
+   * API responses carry relative asset paths such as
+   * `{org}/{channel}/products/{file}.png`. Pass one here to resolve it.
+   *
+   * Treat the result as a *fetch* URL, not a *serve* URL: download the asset
+   * once, store it on your own filesystem or CDN, and serve your copy to end
+   * users. Hot-linking the AsterMD CDN from a storefront is not supported and is
+   * subject to rate limiting.
+   *
+   * @param path Relative asset path as returned by the API; a leading slash is
+   *             optional and is trimmed.
+   * @returns The fully-qualified URL.
+   */
+  assetUrl(path) {
+    return ASSET_BASE_URL + path.replace(/^\/+/, "");
+  }
+};
+
+// src/http/fetch-http-client.ts
+var FetchHttpClient = class {
+  #timeoutSeconds;
+  #fetchImpl;
+  /**
+   * @param timeoutSeconds Per-request deadline in seconds. Must be >= 1.
+   * @param fetchImpl The `fetch` implementation to call. Defaults to the global
+   *                  one; override it to supply an instrumented or stubbed
+   *                  `fetch` without implementing the whole interface.
+   * @throws {TypeError} If `timeoutSeconds` is below 1.
+   */
+  constructor(timeoutSeconds = 10, fetchImpl = globalThis.fetch) {
+    if (timeoutSeconds < 1) {
+      throw new TypeError("timeoutSeconds must be >= 1.");
+    }
+    this.#timeoutSeconds = timeoutSeconds;
+    this.#fetchImpl = fetchImpl;
+  }
+  /**
+   * Sends the request through `fetch` under the configured deadline.
+   *
+   * @param request The request to send.
+   * @returns The response as received, whatever its status.
+   * @throws {TransportError} If the request aborts on the deadline or fails at
+   *   the network layer.
+   */
+  async sendRequest(request) {
+    try {
+      return await this.#fetchImpl(request, {
+        signal: AbortSignal.timeout(this.#timeoutSeconds * 1e3)
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new TransportError(`Request to ${request.url} timed out after ${this.#timeoutSeconds}s.`, {
+          cause: error
+        });
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new TransportError(`Request to ${request.url} failed: ${detail}`, { cause: error });
+    }
+  }
+};
+
+// src/http/log-redactor.ts
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set(["authorization", "x-phi-verification-token"]);
+var SENSITIVE_FIELDS = ["client_secret", "access_token", "refresh_token"];
+var PHI_PATH_FRAGMENTS = ["/patients", "/extensions/identity-verify"];
+var BINARY_UPLOAD_FRAGMENTS = ["/intake-submissions/upload-file/", "/upload-file-multipart/part/"];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var LogRedactor = class _LogRedactor {
+  /** Replacement text substituted for every redacted value. */
+  static PLACEHOLDER = "[REDACTED]";
+  /** Marker written in place of a body dropped wholesale. */
+  static PHI_PLACEHOLDER = "[REDACTED - PHI endpoint]";
+  /** Marker written in place of the raw file bytes of an upload. */
+  static UPLOAD_PLACEHOLDER = "[REDACTED - binary upload]";
+  /**
+   * Returns the loggable form of one request header value.
+   *
+   * A sensitive header keeps its name, so the log still shows the header was
+   * sent, but its value is replaced. For `Authorization` the scheme survives -
+   * `Bearer [REDACTED]` - because knowing the scheme helps when debugging and
+   * carries no secret.
+   *
+   * @param name The header name as it appears on the request.
+   * @param value The raw header value.
+   * @returns The value to write to the log.
+   */
+  headerValue(name, value) {
+    if (!SENSITIVE_HEADERS.has(name.toLowerCase())) {
+      return value;
+    }
+    const scheme = /^(\S+)\s+\S/.exec(value);
+    return scheme === null ? _LogRedactor.PLACEHOLDER : `${scheme[1]} ${_LogRedactor.PLACEHOLDER}`;
+  }
+  /**
+   * Returns the loggable form of a request or response body.
+   *
+   * A body belonging to a PHI-carrying path, and the raw bytes sent to an upload
+   * endpoint, are replaced entirely. Every other body has its sensitive JSON
+   * fields rewritten in place, leaving the surrounding structure intact so the
+   * entry stays readable and replayable apart from the redacted values.
+   *
+   * @param body The raw body as it would otherwise be logged.
+   * @param path The request path, used to detect PHI and upload endpoints.
+   * @returns The body to write to the log.
+   */
+  body(body, path) {
+    if (body === "") {
+      return body;
+    }
+    if (this.isPhiPath(path)) {
+      return _LogRedactor.PHI_PLACEHOLDER;
+    }
+    if (this.isBinaryUploadPath(path)) {
+      return _LogRedactor.UPLOAD_PLACEHOLDER;
+    }
+    return this.#redactFields(body);
+  }
+  /**
+   * Reports whether a path carries PII or PHI and must have its body dropped.
+   *
+   * @param path The request path, with or without the `/v1/{service}` prefix.
+   * @returns `true` for a patient endpoint or the identity-verification endpoint.
+   */
+  isPhiPath(path) {
+    const lower = path.toLowerCase();
+    return PHI_PATH_FRAGMENTS.some((fragment) => lower.includes(fragment));
+  }
+  /**
+   * Reports whether a path carries raw file bytes and must have its body dropped.
+   *
+   * True for the single-shot intake-submission upload endpoint and the multipart
+   * `part` endpoint. The multipart `initiate`, `finish`, and `abort` endpoints
+   * carry small JSON control messages, so they are excluded and their bodies stay
+   * in the log where they help.
+   *
+   * @param path The request path, with or without the `/v1/{service}` prefix.
+   * @returns `true` when the body is file contents rather than JSON.
+   */
+  isBinaryUploadPath(path) {
+    const lower = path.toLowerCase();
+    return BINARY_UPLOAD_FRAGMENTS.some((fragment) => lower.includes(fragment));
+  }
+  /**
+   * Extracts the path from a request, for use with the methods above.
+   *
+   * @param request The request to inspect.
+   * @returns The URL path, without the query string.
+   */
+  pathOf(request) {
+    return new URL(request.url).pathname;
+  }
+  /**
+   * Replaces the value of every sensitive JSON field found in the given text.
+   *
+   * Operates on the serialised form rather than decoding, so it works for
+   * pretty-printed and compact JSON alike and never reorders or reformats a body
+   * that is only partly JSON.
+   */
+  #redactFields(body) {
+    let out = body;
+    for (const field of SENSITIVE_FIELDS) {
+      const pattern = new RegExp(`("${escapeRegExp(field)}"\\s*:\\s*)"(?:[^"\\\\]|\\\\.)*"`, "gi");
+      out = out.replace(pattern, `$1"${_LogRedactor.PLACEHOLDER}"`);
+    }
+    return out;
+  }
+};
+
+// src/http/curl-formatter.ts
+var CurlFormatter = class {
+  /**
+   * Renders the given request as a multi-line curl invocation.
+   *
+   * Each header becomes its own `--header '...'` line. A body is appended as
+   * `--data '...'` with single quotes shell-escaped through the `'\''` idiom.
+   * With no body, the trailing backslash continuation is stripped from the last
+   * line so the command pastes cleanly.
+   *
+   * The request's body is read from a clone, so the request itself stays unread
+   * and can still be sent. Reading the original would leave the real request with
+   * an empty body.
+   *
+   * @param request The request to format.
+   * @param redactor Applied to header values and the body before rendering. Pass
+   *                 `null` or omit it to render verbatim.
+   * @returns The multi-line curl command.
+   */
+  static async format(request, redactor = null) {
+    const lines = [`curl --location --request ${request.method} '${request.url}' \\`];
+    const headerLines = [];
+    for (const [name, value] of request.headers.entries()) {
+      const shown = redactor?.headerValue(name, value) ?? value;
+      headerLines.push(`  --header '${name}: ${shown}' \\`);
+    }
+    let body = await readBody(request);
+    if (redactor !== null) {
+      body = redactor.body(body, redactor.pathOf(request));
+    }
+    if (body !== "") {
+      lines.push(...headerLines);
+      lines.push(`  --data '${body.replaceAll("'", String.raw`'\''`)}'`);
+    } else {
+      headerLines.forEach((line, index) => {
+        lines.push(index === headerLines.length - 1 ? line.replace(/ \\$/, "") : line);
+      });
+      if (headerLines.length === 0) {
+        lines[0] = lines[0].replace(/ \\$/, "");
+      }
+    }
+    return lines.join("\n");
+  }
+};
+async function readBody(request) {
+  if (request.body === null) {
+    return "";
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.startsWith("multipart/form-data")) {
+    return "[multipart/form-data]";
+  }
+  return await request.clone().text();
+}
+
+// src/http/logging-http-client.ts
+var LoggingHttpClient = class {
+  #inner;
+  #sink;
+  #redactor;
+  #formatter;
+  /**
+   * @param options The client to wrap and where to log.
+   */
+  constructor(options) {
+    this.#inner = options.inner;
+    this.#sink = options.sink;
+    this.#redactor = options.redactor === void 0 ? new LogRedactor() : options.redactor;
+    this.#formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone: options.timeZone ?? "UTC",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false,
+      hourCycle: "h23",
+      timeZoneName: "short"
+    });
+  }
+  /**
+   * Forwards the request to the inner client, then logs the exchange.
+   *
+   * @param request The request to send and log.
+   * @returns The response, with its body still readable.
+   * @throws The inner client's error, rethrown after being logged.
+   */
+  async sendRequest(request) {
+    const timestamp = this.#timestamp();
+    const curl = await CurlFormatter.format(request, this.#redactor);
+    let response;
+    try {
+      response = await this.#inner.sendRequest(request);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      await this.#write(`[${timestamp}]
+${curl}
+
+# Transport error: ${detail}
+
+`);
+      throw error;
+    }
+    const raw = await response.clone().text();
+    const shown = this.#redactor?.body(raw, this.#redactor.pathOf(request)) ?? raw;
+    await this.#write(`[${timestamp}]
+${curl}
+
+# Response: HTTP ${response.status}
+${shown}
+
+`);
+    const nullBody = response.status === 204 || response.status === 205 || response.status === 304;
+    return new Response(nullBody ? null : raw, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  async #write(entry) {
+    try {
+      await this.#sink(entry);
+    } catch {
+    }
+  }
+  /**
+   * Formats the current instant as `YYYY-MM-DD HH:MM:SS.ffffff ZONE`.
+   *
+   * PHP logs microseconds; `Date` only resolves to milliseconds, so the
+   * millisecond value is zero-padded to six digits to keep the column width and
+   * the shape of the PHP entries.
+   */
+  #timestamp() {
+    const now = /* @__PURE__ */ new Date();
+    const parts = new Map(this.#formatter.formatToParts(now).map(({ type, value }) => [type, value]));
+    const micros = String(now.getMilliseconds()).padStart(3, "0").padEnd(6, "0");
+    return `${parts.get("year")}-${parts.get("month")}-${parts.get("day")} ${parts.get("hour")}:${parts.get("minute")}:${parts.get("second")}.${micros} ${parts.get("timeZoneName")}`;
+  }
+};
+
+// src/http/url-builder.ts
+function rawUrlEncode(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function buildQuery(query) {
+  return Object.entries(query).map(([key, value]) => {
+    const raw = typeof value === "boolean" ? value ? "1" : "0" : String(value);
+    return `${urlEncode(key)}=${urlEncode(raw)}`;
+  }).join("&");
+}
+function urlEncode(value) {
+  return rawUrlEncode(value).replace(/%20/g, "+").replace(/~/g, "%7E");
+}
+var UrlBuilder = class {
+  #baseHost;
+  /**
+   * @param baseHost Bare hostname to prepend, e.g. `api.astermd.com`.
+   */
+  constructor(baseHost) {
+    this.#baseHost = baseHost;
+  }
+  /**
+   * Constructs the fully-qualified URL for a service and path.
+   *
+   * Placeholder tokens in `path` - `{id}`, `{session}`, `{form_json_identifier}`
+   * - are replaced with the matching values from `pathParams`, percent-encoded.
+   * A placeholder with no matching entry is left untouched rather than guessed
+   * at, which surfaces the programming error in the request URL. Non-empty
+   * `query` entries are serialised and appended after `?`.
+   *
+   * @param service Service segment, e.g. `sales`, `auth`, `platform`.
+   * @param path Path relative to `/v1/{service}`, with optional `{placeholder}`
+   *             tokens.
+   * @param pathParams Placeholder name → replacement value.
+   * @param query Query string parameters.
+   * @returns The fully-qualified URL.
+   */
+  build(service, path, pathParams = {}, query = {}) {
+    let resolved = path;
+    for (const [key, value] of Object.entries(pathParams)) {
+      resolved = resolved.split(`{${key}}`).join(rawUrlEncode(String(value)));
+    }
+    const url = `https://${this.#baseHost}/v1/${service}${resolved}`;
+    const queryString = Object.keys(query).length > 0 ? buildQuery(query) : "";
+    return queryString === "" ? url : `${url}?${queryString}`;
+  }
+};
+var DailyFileLogSink = class {
+  #directory;
+  #stem;
+  #extension;
+  #retentionDays;
+  #dateFormatter;
+  #pruned = false;
+  #tail = Promise.resolve();
+  /**
+   * @param options Base path, retention window, and time zone.
+   * @throws {TypeError} If `basePath` is empty or carries no file name, or if
+   *   `retentionDays` is negative.
+   */
+  constructor(options) {
+    const { basePath, retentionDays = 7, timeZone = "UTC" } = options;
+    if (basePath.trim() === "") {
+      throw new TypeError("basePath must be a non-empty file path.");
+    }
+    if (retentionDays < 0) {
+      throw new TypeError("retentionDays must be >= 0 (0 disables pruning).");
+    }
+    const extension = path.extname(basePath);
+    const stem = path.basename(basePath, extension);
+    if (stem === "") {
+      throw new TypeError(`basePath must include a file name. Got: ${basePath}`);
+    }
+    this.#directory = path.dirname(basePath);
+    this.#stem = stem;
+    this.#extension = extension === "" ? ".log" : extension;
+    this.#retentionDays = retentionDays;
+    this.#dateFormatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+  }
+  /**
+   * Appends one entry to today's log file, pruning aged-out files on the first
+   * call.
+   *
+   * Resolves once the entry is on disk. Writes are chained, so entries land whole
+   * and in call order even under concurrency. Never rejects: an I/O failure is
+   * swallowed rather than propagated into the API call being logged.
+   *
+   * @param entry The formatted log entry to append.
+   */
+  async write(entry) {
+    this.#tail = this.#tail.then(() => this.#append(entry)).catch(() => void 0);
+    await this.#tail;
+  }
+  /**
+   * Returns the absolute path entries are currently written to.
+   *
+   * Useful in tests and for a "where are my logs" diagnostic. The path changes at
+   * midnight in the configured time zone.
+   *
+   * @returns The dated file path, e.g. `/var/log/astermd/sdk-2026-09-08.log`.
+   */
+  currentFile() {
+    return path.join(this.#directory, `${this.#stem}-${this.#today()}${this.#extension}`);
+  }
+  async #append(entry) {
+    try {
+      await promises.mkdir(this.#directory, { recursive: true, mode: 448 });
+      await promises.appendFile(this.currentFile(), entry, { mode: 384 });
+      if (!this.#pruned) {
+        this.#pruned = true;
+        await this.#prune();
+      }
+    } catch {
+    }
+  }
+  /**
+   * Deletes dated log files older than the retention window.
+   *
+   * Only files matching this sink's own `{stem}-YYYY-MM-DD{ext}` pattern are
+   * considered, and the date comes from the filename rather than filesystem
+   * metadata. A file that cannot be deleted is skipped silently.
+   */
+  async #prune() {
+    if (this.#retentionDays === 0) {
+      return;
+    }
+    const cutoff = this.#cutoff();
+    const pattern = new RegExp(`^${escapeRegExp2(this.#stem)}-(\\d{4}-\\d{2}-\\d{2})${escapeRegExp2(this.#extension)}$`);
+    let names;
+    try {
+      names = await promises.readdir(this.#directory);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const matched = pattern.exec(name);
+      if (matched !== null && matched[1] < cutoff) {
+        try {
+          await promises.rm(path.join(this.#directory, name), { force: true });
+        } catch {
+        }
+      }
+    }
+  }
+  #today() {
+    return this.#dateFormatter.format(/* @__PURE__ */ new Date());
+  }
+  /** The oldest date still kept, as `YYYY-MM-DD`. */
+  #cutoff() {
+    const today = /* @__PURE__ */ new Date(`${this.#today()}T00:00:00.000Z`);
+    today.setUTCDate(today.getUTCDate() - this.#retentionDays);
+    return today.toISOString().slice(0, 10);
+  }
+};
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/resource/abstract-resource.ts
+var AbstractResource = class {
+  /** The shared transport used for all outbound API calls. */
+  transport;
+  /**
+   * @param transport The transport every call from this resource goes through.
+   */
+  constructor(transport) {
+    this.transport = transport;
+  }
+};
+
+// src/resource/carts.ts
+var Carts = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Creates the cart for a session.
+   *
+   * Call this the first time the visitor puts something in their cart. The
+   * session must already exist. If a cart is already recorded for the session,
+   * use {@link Carts.update} instead.
+   *
+   * @param options The session and the cart's contents.
+   * @returns The created cart.
+   * @throws {ValidationError} If the session or an item is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/carts/create",
+      body: { session: options.session, items: options.items }
+    });
+  }
+  /**
+   * Replaces the contents of a session's cart.
+   *
+   * The item list is authoritative: whatever you send becomes the cart. Send the
+   * full list on every change rather than only what moved, and pass an empty list
+   * to record that the visitor emptied their cart.
+   *
+   * @param options The session and the cart's new contents.
+   * @returns The updated cart.
+   * @throws {NotFoundError} If no cart exists for the session.
+   * @throws {ValidationError} If an item is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/carts/update/{session}",
+      pathParams: { session: options.session },
+      body: { items: options.items }
+    });
+  }
+};
+
+// src/resource/categories.ts
+var Categories = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Lists categories, filtered and paginated.
+   *
+   * Pagination details come back in `meta()`. The accepted filters are in the
+   * API reference in your AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching categories, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/categories/list",
+      query
+    });
+  }
+  /**
+   * Fetches one category.
+   *
+   * @param id The category's id.
+   * @returns The category record.
+   * @throws {NotFoundError} If the category does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/categories/view/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/resource/channels.ts
+var Channels = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Fetches a channel's own configuration.
+   *
+   * The channel record itself - name, type, status - without its product
+   * catalogue.
+   *
+   * @param id The channel's id.
+   * @returns The channel record.
+   * @throws {NotFoundError} If the channel does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/channels/view/{id}",
+      pathParams: { id }
+    });
+  }
+  /**
+   * Fetches the products assigned to a channel.
+   *
+   * What this selling surface is permitted to sell. Use it to build a catalogue
+   * page without pulling the full detail tree.
+   *
+   * @param id The channel's id.
+   * @returns The assigned products.
+   * @throws {NotFoundError} If the channel does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async assignedProducts(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/channels/assigned-products/{id}",
+      pathParams: { id }
+    });
+  }
+  /**
+   * Fetches a channel's complete configuration tree.
+   *
+   * Channel, payment processor, products, variants, prices, and per-integration
+   * mappings in one response - everything a storefront needs to render its
+   * catalogue without further calls. The envelope is deeply nested and carries
+   * server-side field names; see the API reference in your AsterMD dashboard for
+   * its shape. Pass `data()` through {@link ChannelDetail.from} to flatten it.
+   *
+   * @param id The channel's id.
+   * @returns The full configuration tree.
+   * @throws {NotFoundError} If the channel does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async details(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/channels/detail/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/enum/checkout-event.ts
+var CheckoutEvent = Object.freeze({
+  /** The prospect reached the checkout page. Recorded implicitly by `create()`. */
+  CheckoutVisited: "checkout_visited",
+  /** An upsell was presented to the prospect. */
+  UpsellOffered: "upsell_offered",
+  /** The prospect accepted a presented upsell. */
+  UpsellAccepted: "upsell_accepted",
+  /** The prospect declined a presented upsell. */
+  UpsellDeclined: "upsell_declined",
+  /** The order was placed successfully. */
+  OrderPlaced: "order_placed",
+  /** The order was declined, typically by the payment processor. */
+  OrderDeclined: "order_declined"
+});
+
+// src/resource/checkout-events.ts
+var DEFAULT_CURRENCY = "USD";
+var CheckoutEvents = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Opens the checkout record for a session, registering `checkout_visited`.
+   *
+   * Call this once, when the visitor reaches the checkout page. The event is
+   * fixed - this is the call that starts the funnel record - and `currency`
+   * defaults to `USD` when you do not supply one, since the server requires a
+   * currency to interpret any amounts in the payload.
+   *
+   * @param session The session reaching checkout.
+   * @param data Additional context, e.g. `cart_total`, `items_count`,
+   *   `currency`. Cannot override `session` or `event`.
+   * @returns The created checkout-event record.
+   * @throws {ValidationError} If the session or payload is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(session, data = {}) {
+    const body = {
+      ...data,
+      session,
+      event: CheckoutEvent.CheckoutVisited
+    };
+    if (body.currency === void 0 || body.currency === "") {
+      body.currency = DEFAULT_CURRENCY;
+    }
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/checkout-events/create",
+      body
+    });
+  }
+  /**
+   * Advances a session's checkout record to a new funnel state.
+   *
+   * Send one call per state the visitor reaches: an upsell offered, then accepted
+   * or declined, then the order placed or declined. The payload carries whatever
+   * context that state needs, but it can never override `event` - the state
+   * recorded is always the one you passed explicitly.
+   *
+   * @param options The session, the new state, and any context for it.
+   * @returns The updated checkout-event record.
+   * @throws {NotFoundError} If no checkout record exists for the session.
+   * @throws {ValidationError} If the event or payload is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/checkout-events/update/{session_id}",
+      pathParams: { session_id: options.session },
+      body: { ...options.data ?? {}, event: options.event }
+    });
+  }
+};
+
+// src/resource/doctors-networks.ts
+var DoctorsNetworks = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Pushes a case to the configured doctors' network.
+   *
+   * The payload must identify who the case is about, one of two ways: an
+   * `opportunity_id` for a prospect already recorded, or a `user_info` object
+   * carrying at least `first_name` and `email` for one who is not. Everything
+   * else is forwarded unmodified.
+   *
+   * An `emit_opportunity` key is removed before sending - that flag is the
+   * server's to set, not a caller's. Your object is not modified; the SDK copies
+   * it first.
+   *
+   * @param payload The case to push. Requires either a non-empty
+   *   `opportunity_id` string, or a `user_info` object with non-empty
+   *   `first_name` and `email` strings.
+   * @returns The sync result.
+   * @throws {TypeError} If the payload identifies neither an opportunity nor a
+   *   person.
+   * @throws {ValidationError} If the server rejects a field.
+   * @throws {NotFoundError} If the referenced opportunity does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async sync(payload) {
+    const body = { ...payload };
+    delete body.emit_opportunity;
+    validate(body);
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/doctors-networks/sync",
+      body
+    });
+  }
+};
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function validate(payload) {
+  const hasOpportunity = isNonEmptyString(payload.opportunity_id);
+  const userInfo = payload.user_info;
+  const hasMinimalUserInfo = typeof userInfo === "object" && userInfo !== null && isNonEmptyString(userInfo.first_name) && isNonEmptyString(userInfo.email);
+  if (!hasOpportunity && !hasMinimalUserInfo) {
+    throw new TypeError("doctors-networks/sync requires either opportunity_id or user_info with first_name + email.");
+  }
+}
+
+// src/resource/geo.ts
+var Geo = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Resolves an IP address to a geographic location.
+   *
+   * Returns the configured provider's answer, normalised. Treat it as a strong
+   * hint rather than proof - a VPN or a mobile carrier's routing can place a
+   * visitor a long way from where they are. For a licensing decision, prefer
+   * {@link Geo.blocklist} and the state the visitor declares.
+   *
+   * @param ip The visitor's IP address, v4 or v6.
+   * @returns The resolved location.
+   * @throws {ValidationError} If the address is malformed.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async info(ip) {
+    return await this.transport.send({
+      service: "platform",
+      method: "GET",
+      path: "/extensions/geo-info",
+      query: { ip }
+    });
+  }
+  /**
+   * Reports whether an IP address is barred from starting an order flow.
+   *
+   * Covers jurisdictions your organisation is not licensed for, along with known
+   * proxies and anonymisers. Call it as early as the landing page: refusing a
+   * visitor before they invest time in a questionnaire is better for them and
+   * cheaper for you.
+   *
+   * @param ip The visitor's IP address, v4 or v6.
+   * @returns The blocklist verdict.
+   * @throws {ValidationError} If the address is malformed.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async blocklist(ip) {
+    return await this.transport.send({
+      service: "platform",
+      method: "GET",
+      path: "/extensions/geo-blocklist",
+      query: { ip }
+    });
+  }
+};
+var MIME_TYPES = Object.freeze({
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp",
+  gif: "image/gif",
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  txt: "text/plain",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm"
+});
+var FALLBACK_MIME_TYPE = "application/octet-stream";
+var FileUpload = class _FileUpload {
+  #contents;
+  #fileName;
+  #mimeType;
+  constructor(contents, fileName, mimeType) {
+    this.#contents = contents;
+    this.#fileName = fileName;
+    this.#mimeType = mimeType;
+    Object.freeze(this);
+  }
+  /**
+   * Reads a file from local disk into an upload.
+   *
+   * The file is read in full and held in memory, so keep this for the sizes the
+   * single-shot endpoints allow. Without `options.fileName` the path's base name
+   * is used, and without `options.mimeType` the type is derived from the
+   * extension, falling back to `application/octet-stream`.
+   *
+   * @param path Path to an existing, readable file.
+   * @param options Optional name and MIME type overrides.
+   * @returns An upload carrying the file's bytes, name, and MIME type.
+   * @throws {TypeError} If `path` is not a readable file, or if the resulting
+   *   file name normalises to nothing usable.
+   */
+  static async fromPath(path$1, options = {}) {
+    let isFile;
+    try {
+      isFile = (await promises.stat(path$1)).isFile();
+    } catch {
+      isFile = false;
+    }
+    if (!isFile) {
+      throw new TypeError(`File is not readable: ${path$1}`);
+    }
+    let contents;
+    try {
+      contents = await promises.readFile(path$1);
+    } catch (error) {
+      throw new TypeError(`Failed to read file: ${path$1}`, { cause: error });
+    }
+    const name = normaliseFileName(options.fileName ?? path.basename(path$1));
+    return new _FileUpload(new Uint8Array(contents), name, options.mimeType ?? guessMimeType(name));
+  }
+  /**
+   * Wraps bytes already held in memory into an upload.
+   *
+   * Use this when the bytes never came from a file on disk: a slice of a larger
+   * file being sent through the multipart flow, a payload received over the
+   * wire, or content generated at runtime. `fileName` is required because there
+   * is no path to derive one from.
+   *
+   * @param contents The raw bytes to send as the part body.
+   * @param fileName Name to send in the part header.
+   * @param options Optional MIME type override.
+   * @returns An upload carrying the given bytes, name, and MIME type.
+   * @throws {TypeError} If `fileName` normalises to nothing usable.
+   */
+  static fromContents(contents, fileName, options = {}) {
+    const name = normaliseFileName(fileName);
+    return new _FileUpload(contents, name, options.mimeType ?? guessMimeType(name));
+  }
+  /**
+   * Returns the raw bytes that will form the body of the multipart part.
+   *
+   * @returns The file's contents.
+   */
+  contents() {
+    return this.#contents;
+  }
+  /**
+   * Returns the normalised file name sent in the part header.
+   *
+   * The server uses this to derive the stored object name, inserting a unique
+   * identifier before the extension so repeat uploads of the same name never
+   * collide.
+   *
+   * @returns The file name, stripped of directory components and
+   *   header-breaking characters.
+   */
+  fileName() {
+    return this.#fileName;
+  }
+  /**
+   * Returns the MIME type sent for the part.
+   *
+   * @returns The MIME type, e.g. `image/jpeg`.
+   */
+  mimeType() {
+    return this.#mimeType;
+  }
+  /**
+   * Returns the size of the upload in bytes.
+   *
+   * Useful for checking a file against an endpoint's documented limit before
+   * spending a round trip on it, and for the `fileSize` value the multipart
+   * initiate call requires.
+   *
+   * @returns The number of bytes in {@link FileUpload.contents}.
+   */
+  size() {
+    return this.#contents.byteLength;
+  }
+};
+function normaliseFileName(fileName) {
+  const stripped = fileName.trim().replace(/[\r\n"\\]/g, "");
+  const name = path.basename(stripped).trim();
+  if (name === "" || name === "." || name === "..") {
+    throw new TypeError("File name must not be empty.");
+  }
+  return name;
+}
+function guessMimeType(fileName) {
+  const extension = path.extname(fileName).replace(/^\./, "").toLowerCase();
+  return MIME_TYPES[extension] ?? FALLBACK_MIME_TYPE;
+}
+
+// src/resource/intake-submissions.ts
+var IntakeSubmissions = class _IntakeSubmissions extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Fetches one intake submission and its recorded answers.
+   *
+   * The teleform id is required alongside the submission id because a submission
+   * is only meaningful against the form it answers - the server uses it to
+   * resolve field definitions for the stored values.
+   *
+   * @param options The submission id and the teleform it answers.
+   * @returns The submission and its answers.
+   * @throws {NotFoundError} If the submission does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/intake-submissions/view/{id}",
+      pathParams: { id: options.id },
+      query: { teleform_id: options.teleformId }
+    });
+  }
+  /**
+   * Creates the intake-submission record for a session and records the first
+   * answers.
+   *
+   * This is the call that opens the record, so it takes an `*Initiated` event -
+   * `Event.PreQualifyingInitiated` or `Event.IntakeInitiated`. Every later step
+   * goes to {@link IntakeSubmissions.update}. The server advances its order-flow
+   * state machine on the event, so passing the wrong one puts the flow in the
+   * wrong state rather than failing loudly.
+   *
+   * @param options The session, event, teleform, answers, and optional progress.
+   * @returns The created submission.
+   * @throws {ValidationError} If the answers or the event are rejected.
+   * @throws {NotFoundError} If the session or teleform does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/create",
+      body: intakeBody(options)
+    });
+  }
+  /**
+   * Records further answers against an existing intake submission.
+   *
+   * Takes an `*InProgress` event for an intermediate step or a `*Completed` event
+   * for the final submission. `data` is cumulative - send every answer collected
+   * so far, since the server treats the payload as the current state of the form
+   * rather than a patch.
+   *
+   * @param options The session, event, teleform, answers, and optional progress.
+   * @returns The updated submission.
+   * @throws {ValidationError} If the answers or the event are rejected.
+   * @throws {NotFoundError} If no submission exists for the session.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/intake-submissions/update/{session}",
+      pathParams: { session: options.session },
+      body: intakeBody(options)
+    });
+  }
+  /** Smallest part the multipart endpoint accepts: 5 MB. */
+  static MIN_PART_SIZE = 5 * 1024 * 1024;
+  /** Largest part the multipart endpoint accepts: 25 MB. */
+  static MAX_PART_SIZE = 25 * 1024 * 1024;
+  /** Part size {@link IntakeSubmissions.uploadLargeFile} uses by default: 10 MB. */
+  static DEFAULT_PART_SIZE = 10 * 1024 * 1024;
+  /**
+   * Uploads one file in a single request, for a file-type answer.
+   *
+   * Use this for the sizes a single request can carry - a photograph of an ID, a
+   * PDF. The whole file is held in memory and sent as one `multipart/form-data`
+   * body. For anything large enough to risk a timeout, use
+   * {@link IntakeSubmissions.uploadLargeFile} instead.
+   *
+   * The response carries the stored file's reference, which is what you place in
+   * the `value` of the corresponding field when you next call
+   * {@link IntakeSubmissions.update}.
+   *
+   * @param options The session and the file.
+   * @returns The stored file's reference.
+   * @throws {ValidationError} If the file type or size is rejected.
+   * @throws {NotFoundError} If the session does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async uploadFile(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/upload-file/{session_id}",
+      pathParams: { session_id: options.sessionId },
+      file: options.file
+    });
+  }
+  /**
+   * Opens a multipart upload and returns the id the parts will be sent under.
+   *
+   * The first of the four low-level multipart calls. Declare the *whole* file's
+   * name, type, and size here - the server uses the size to validate the parts it
+   * later receives. Prefer {@link IntakeSubmissions.uploadLargeFile}, which
+   * drives all four calls; reach for these directly only when you need to
+   * control the loop, for instance to upload parts from several workers.
+   *
+   * @param options The session and the whole file's metadata.
+   * @returns The opened upload; `data().upload_id` carries the id.
+   * @throws {ValidationError} If the metadata is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async initiateMultipartUpload(options) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/upload-file-multipart/initiate/{session_id}",
+      pathParams: { session_id: options.sessionId },
+      body: {
+        file_name: options.fileName,
+        mime_type: options.mimeType,
+        file_size: options.fileSize
+      }
+    });
+  }
+  /**
+   * Uploads one part of an open multipart upload.
+   *
+   * Part numbers are 1-based and must arrive with the part they label; the
+   * response carries an etag you must keep, because
+   * {@link IntakeSubmissions.finishMultipartUpload} needs every part's etag to
+   * assemble the file. Parts may be uploaded in any order.
+   *
+   * @param options The upload id, the part number, and the part's bytes.
+   * @returns The stored part; `data().etag` carries the etag.
+   * @throws {TypeError} If `partNumber` is outside 1–10000.
+   * @throws {NotFoundError} If the upload id is unknown or already finished.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async uploadMultipartPart(options) {
+    if (options.partNumber < 1 || options.partNumber > 1e4) {
+      throw new TypeError(`Part number must be between 1 and 10000, got ${options.partNumber}.`);
+    }
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/upload-file-multipart/part/{upload_id}",
+      pathParams: { upload_id: options.uploadId },
+      query: { part_number: options.partNumber },
+      file: options.part
+    });
+  }
+  /**
+   * Closes a multipart upload, assembling the parts into one stored file.
+   *
+   * Send every part with the etag its own upload returned. The server verifies
+   * the set against what it received, so a missing or mismatched part fails here
+   * rather than producing a corrupt file.
+   *
+   * @param options The upload id and every part with its etag.
+   * @returns The stored file's reference.
+   * @throws {TypeError} If `parts` is empty.
+   * @throws {ValidationError} If the parts do not match what the server holds.
+   * @throws {NotFoundError} If the upload id is unknown.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async finishMultipartUpload(options) {
+    if (options.parts.length === 0) {
+      throw new TypeError("At least one part is required to finish a multipart upload.");
+    }
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/upload-file-multipart/finish/{upload_id}",
+      pathParams: { upload_id: options.uploadId },
+      body: { parts: options.parts }
+    });
+  }
+  /**
+   * Abandons a multipart upload and discards the parts already stored.
+   *
+   * Call this when an upload cannot be completed, so the parts do not linger.
+   * {@link IntakeSubmissions.uploadLargeFile} does it for you on failure.
+   *
+   * @param uploadId The upload id to abandon.
+   * @returns The abort confirmation.
+   * @throws {NotFoundError} If the upload id is unknown or already finished.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async abortMultipartUpload(uploadId) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/intake-submissions/upload-file-multipart/abort/{upload_id}",
+      pathParams: { upload_id: uploadId }
+    });
+  }
+  /**
+   * Uploads a large file from disk, driving the whole multipart flow.
+   *
+   * This is the method to reach for when a file is too big for one request. It
+   * streams the file one part at a time, so a 200 MB video costs one part of
+   * memory rather than 200 MB: initiate, then read a part, upload it, keep its
+   * etag, repeat, then finish. If any step fails the upload is aborted so no
+   * parts are left behind, and the failure that broke the upload is what
+   * surfaces - not the abort's own outcome.
+   *
+   * The first part fixes the name and MIME type for the whole upload, so
+   * `initiate` and every part agree.
+   *
+   * ```ts
+   * const stored = await client.intakeSubmissions().uploadLargeFile({
+   *   sessionId,
+   *   filePath: '/var/uploads/consult-video.mp4',
+   * });
+   * ```
+   *
+   * @param options The session, the file's path, and optional name, MIME type,
+   *   and part size.
+   * @returns The finished upload's response - the same one
+   *   {@link IntakeSubmissions.finishMultipartUpload} returns.
+   * @throws {TypeError} If `partSize` is outside the allowed range, or if the
+   *   file is missing, unreadable, or empty.
+   * @throws {ApiError} If the server response omits a usable `upload_id` or
+   *   `etag`, or on any other non-2xx status.
+   * @throws {TransportError} If a request never completed.
+   */
+  async uploadLargeFile(options) {
+    const partSize = options.partSize ?? _IntakeSubmissions.DEFAULT_PART_SIZE;
+    if (partSize < _IntakeSubmissions.MIN_PART_SIZE || partSize > _IntakeSubmissions.MAX_PART_SIZE) {
+      throw new TypeError(
+        `Part size must be between ${_IntakeSubmissions.MIN_PART_SIZE} and ${_IntakeSubmissions.MAX_PART_SIZE} bytes, got ${partSize}.`
+      );
+    }
+    let fileSize;
+    try {
+      const stats = await promises.stat(options.filePath);
+      if (!stats.isFile()) {
+        throw new TypeError(`File is not readable: ${options.filePath}`);
+      }
+      fileSize = stats.size;
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw error;
+      }
+      throw new TypeError(`File is not readable: ${options.filePath}`, {
+        cause: error
+      });
+    }
+    if (fileSize === 0) {
+      throw new TypeError(`File is empty: ${options.filePath}`);
+    }
+    const handle = await promises.open(options.filePath, "r");
+    try {
+      const buffer = Buffer.alloc(partSize);
+      const firstBytesRead = await readFull(handle, buffer, partSize);
+      if (firstBytesRead === 0) {
+        throw new TypeError(`File is empty: ${options.filePath}`);
+      }
+      let part = FileUpload.fromContents(
+        new Uint8Array(buffer.subarray(0, firstBytesRead)),
+        options.fileName ?? path.basename(options.filePath),
+        options.mimeType === void 0 ? {} : { mimeType: options.mimeType }
+      );
+      const uploadId = stringField(
+        await this.initiateMultipartUpload({
+          sessionId: options.sessionId,
+          fileName: part.fileName(),
+          mimeType: part.mimeType(),
+          fileSize
+        }),
+        "upload_id"
+      );
+      try {
+        const parts = [];
+        let partNumber = 1;
+        for (; ; ) {
+          const result = await this.uploadMultipartPart({
+            uploadId,
+            partNumber,
+            part
+          });
+          parts.push({
+            part_number: partNumber,
+            etag: stringField(result, "etag")
+          });
+          const nextBytesRead = await readFull(handle, buffer, partSize);
+          if (nextBytesRead === 0) {
+            break;
+          }
+          partNumber += 1;
+          part = FileUpload.fromContents(new Uint8Array(buffer.subarray(0, nextBytesRead)), part.fileName(), {
+            mimeType: part.mimeType()
+          });
+        }
+        return await this.finishMultipartUpload({ uploadId, parts });
+      } catch (error) {
+        try {
+          await this.abortMultipartUpload(uploadId);
+        } catch {
+        }
+        throw error;
+      }
+    } finally {
+      await handle.close().catch(() => void 0);
+    }
+  }
+};
+async function readFull(handle, buffer, length) {
+  let filled = 0;
+  while (filled < length) {
+    const { bytesRead } = await handle.read(buffer, filled, length - filled, null);
+    if (bytesRead === 0) {
+      break;
+    }
+    filled += bytesRead;
+  }
+  return filled;
+}
+function intakeBody(options) {
+  const body = {
+    session: options.session,
+    event: options.event,
+    teleform_id: options.teleformId,
+    data: options.data
+  };
+  if (options.progress !== void 0) {
+    body.progress = options.progress;
+  }
+  return body;
+}
+function stringField(response, key) {
+  const value = response.data()[key];
+  if (typeof value !== "string" || value === "") {
+    throw new ApiError(`The server response did not include a usable ${key}.`, response.statusCode(), {});
+  }
+  return value;
+}
+
+// src/resource/lab-tests.ts
+var LabTests = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Lists lab tests, filtered and paginated.
+   *
+   * Pagination details come back in `meta()`. The accepted filters are in the
+   * API reference in your AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching lab tests, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/lab-tests/list",
+      query
+    });
+  }
+  /**
+   * Fetches one lab test.
+   *
+   * @param id The lab test's id.
+   * @returns The lab test record.
+   * @throws {NotFoundError} If the lab test does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/lab-tests/view/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/resource/medications.ts
+var Medications = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Lists medications, filtered and paginated.
+   *
+   * Intended to back a search or type-ahead on an intake form. Pagination comes
+   * back in `meta()`; the accepted filters are in the API reference in your
+   * AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching medications, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/medications/list",
+      query
+    });
+  }
+};
+
+// src/resource/opportunities.ts
+var Opportunities = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Creates an opportunity.
+   *
+   * Include a `sessions` array of the session identifiers that led here, so the
+   * server can attribute the lead. The rest of the payload is forwarded
+   * unmodified.
+   *
+   * @param data The prospect's details and the sessions to attach.
+   * @returns The created opportunity, including its id.
+   * @throws {ValidationError} If a field is missing or rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/opportunities/create",
+      body: data
+    });
+  }
+  /**
+   * Fetches one opportunity.
+   *
+   * @param id The opportunity's id.
+   * @returns The opportunity record.
+   * @throws {NotFoundError} If the opportunity does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/opportunities/view/{id}",
+      pathParams: { id }
+    });
+  }
+  /**
+   * Updates an opportunity.
+   *
+   * Send only the fields you are changing. Use this to enrich a lead as more
+   * information arrives - a phone number, a later session to attach.
+   *
+   * @param id The opportunity's id.
+   * @param data The fields to change.
+   * @returns The updated opportunity.
+   * @throws {NotFoundError} If the opportunity does not exist.
+   * @throws {ValidationError} If a field is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(id, data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/opportunities/update/{id}",
+      pathParams: { id },
+      body: data
+    });
+  }
+  /**
+   * Changes an opportunity's status.
+   *
+   * Kept separate from {@link Opportunities.update} so a pipeline transition is
+   * explicit in your code and in the server's audit trail. The accepted values
+   * are configured for your organisation; see the API reference in your AsterMD
+   * dashboard.
+   *
+   * @param id The opportunity's id.
+   * @param status The new status value, sent as `opportunity_status`.
+   * @returns The updated opportunity.
+   * @throws {NotFoundError} If the opportunity does not exist.
+   * @throws {ValidationError} If the status is not an accepted value.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async status(id, status) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PATCH",
+      path: "/opportunities/status/{id}",
+      pathParams: { id },
+      body: { opportunity_status: status }
+    });
+  }
+};
+
+// src/resource/patients.ts
+var Patients = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Creates a patient record.
+   *
+   * Call this once the prospect has qualified and is proceeding. The payload is
+   * forwarded unmodified, so it carries whatever demographic and contact fields
+   * your organisation's configuration requires.
+   *
+   * @param data The patient's details. See the API reference in your AsterMD
+   *   dashboard for the accepted fields.
+   * @returns The created patient; `data()` carries the new record including its id.
+   * @throws {ValidationError} If a field is missing or rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/patients/create",
+      body: data
+    });
+  }
+  /**
+   * Fetches one patient record.
+   *
+   * Returns the record as your credentials are permitted to see it. Because the
+   * organisation scope lives inside the JWT, an id belonging to another
+   * organisation is indistinguishable from one that never existed - both raise
+   * {@link NotFoundError}.
+   *
+   * @param id The patient's id.
+   * @returns The patient record.
+   * @throws {NotFoundError} If the patient does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/patients/view/{id}",
+      pathParams: { id }
+    });
+  }
+  /**
+   * Updates a patient record.
+   *
+   * Send only the fields you are changing; the server merges them into the
+   * existing record rather than replacing it.
+   *
+   * @param id The patient's id.
+   * @param data The fields to change.
+   * @returns The updated patient record.
+   * @throws {NotFoundError} If the patient does not exist.
+   * @throws {ValidationError} If a field is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(id, data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/patients/update/{id}",
+      pathParams: { id },
+      body: data
+    });
+  }
+  /**
+   * Changes a patient's status.
+   *
+   * A narrow call for the one field that drives workflow state, kept separate
+   * from {@link Patients.update} so a status transition is explicit in your code
+   * and in the server's audit trail. The accepted values are configured for your
+   * organisation; see the API reference in your AsterMD dashboard.
+   *
+   * @param id The patient's id.
+   * @param status The new status value.
+   * @returns The updated patient record.
+   * @throws {NotFoundError} If the patient does not exist.
+   * @throws {ValidationError} If the status is not an accepted value.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async status(id, status) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PATCH",
+      path: "/patients/status/{id}",
+      pathParams: { id },
+      body: { status }
+    });
+  }
+  /**
+   * Submits a patient's health information.
+   *
+   * This is the clinical questionnaire result a clinician reviews, and the most
+   * sensitive payload the SDK carries. Where the server requires explicit patient
+   * confirmation, obtain a token through
+   * {@link Patients.verifyHealthInformationOtp} first and pass it as
+   * `phiVerificationToken`.
+   *
+   * Neither the request nor the response body is ever written to a debug log.
+   *
+   * @param options The health information, and the verification token where one
+   *   is required.
+   * @returns The stored submission.
+   * @throws {AuthenticationError} If the verification token is missing or invalid.
+   * @throws {ValidationError} If the payload is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async submitHealthInformation(options) {
+    const headers = options.phiVerificationToken !== void 0 ? { "x-phi-verification-token": options.phiVerificationToken } : {};
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/patients/health-information",
+      body: options.data,
+      headers
+    });
+  }
+  /**
+   * Verifies the one-time code a patient was sent, before health information is
+   * submitted.
+   *
+   * The confirming half of the two-step health-information flow. On success the
+   * response carries the verification token to pass to
+   * {@link Patients.submitHealthInformation}.
+   *
+   * The one-time code is a credential: it is never written to a debug log, and it
+   * should not be written to yours either.
+   *
+   * @param data The patient identifier and the one-time code. See the API
+   *   reference in your AsterMD dashboard for the exact fields.
+   * @returns The verification result, carrying the token on success.
+   * @throws {ValidationError} If the code is wrong, expired, or malformed.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async verifyHealthInformationOtp(data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/patients/health-information/otp-verification",
+      body: data
+    });
+  }
+};
+
+// src/resource/products.ts
+var Products = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Lists products, filtered and paginated.
+   *
+   * Pagination details come back in `meta()`. The accepted filters are in the
+   * API reference in your AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching products, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/products/list",
+      query
+    });
+  }
+  /**
+   * Fetches one product, including its variants and prices.
+   *
+   * @param id The product's id.
+   * @returns The product record.
+   * @throws {NotFoundError} If the product does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/products/view/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/resource/sessions.ts
+var Sessions = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Creates a new session and returns its identifier.
+   *
+   * This is the first call of an order flow. The server records an implicit
+   * `visit_page` event alongside the new session, so the funnel begins here.
+   * Inspect `data().session` on the response for the identifier to thread through
+   * every later call.
+   *
+   * @param options Attribution payload and visitor headers. All optional; with
+   *   none, an empty object body is sent.
+   * @returns The created session; `data()` holds `{ session }`.
+   * @throws {ValidationError} If the attribution payload is rejected.
+   * @throws {AuthenticationError} If the credentials are refused.
+   * @throws {RateLimitError} If the organisation's request allowance is exceeded.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(options = {}) {
+    const headers = {};
+    if (options.userAgent !== void 0 && options.userAgent !== "") {
+      headers["User-Agent"] = options.userAgent;
+    }
+    if (options.clientIp !== void 0 && options.clientIp !== "") {
+      headers["X-Original-Client-Ip"] = options.clientIp;
+    }
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/sessions/create",
+      body: options.data ?? {},
+      headers
+    });
+  }
+  /**
+   * Fetches one or more sessions and the events recorded against them.
+   *
+   * Useful for reconstructing a visitor's journey server-side - which forms they
+   * touched, where they stopped. Several identifiers can be fetched in one call,
+   * which is cheaper than looping. Timestamps come back in `tz` when you supply
+   * one, and in the organisation's default zone otherwise.
+   *
+   * @param options The session identifiers to fetch, and an optional time zone.
+   * @returns The sessions and their recorded events.
+   * @throws {NotFoundError} If none of the identifiers resolve.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(options) {
+    const query = {
+      session_ids: options.sessions.join(",")
+    };
+    if (options.tz !== void 0 && options.tz !== "") {
+      query.tz = options.tz;
+    }
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/sessions/view",
+      query
+    });
+  }
+  /**
+   * Updates the attribution and context recorded against an existing session.
+   *
+   * Call this when information arrives after the session was created - a UTM
+   * parameter only present on a later page, a referrer resolved asynchronously.
+   * The payload is merged server-side rather than replacing what is already
+   * recorded.
+   *
+   * @param session The session identifier to update.
+   * @param data Fields to record. Forwarded unmodified; see the API reference in
+   *   your AsterMD dashboard for the recognised keys.
+   * @returns The updated session.
+   * @throws {NotFoundError} If the session does not exist.
+   * @throws {ValidationError} If the payload is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async update(session, data = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "PUT",
+      path: "/sessions/update/{id}",
+      pathParams: { id: session },
+      body: data
+    });
+  }
+  /**
+   * Deletes a session and the events recorded against it.
+   *
+   * Intended for honouring a visitor's erasure request, not for ordinary
+   * cleanup - sessions age out server-side on their own. Deleting one removes the
+   * attribution trail for anything that referenced it.
+   *
+   * @param session The session identifier to delete.
+   * @returns The deletion confirmation.
+   * @throws {NotFoundError} If the session does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async delete(session) {
+    return await this.transport.send({
+      service: "sales",
+      method: "DELETE",
+      path: "/sessions/delete/{id}",
+      pathParams: { id: session }
+    });
+  }
+};
+
+// src/resource/shippings.ts
+var Shippings = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Lists shipping options, filtered and paginated.
+   *
+   * Pagination details come back in `meta()`. The accepted filters are in the
+   * API reference in your AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching shipping options, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/shippings/list",
+      query
+    });
+  }
+  /**
+   * Fetches one shipping option.
+   *
+   * @param id The shipping option's id.
+   * @returns The shipping option record.
+   * @throws {NotFoundError} If the shipping option does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/shippings/view/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/resource/teleforms.ts
+var Teleforms = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Fetches a teleform definition by its configured identifier.
+   *
+   * This is the call a storefront usually wants: the identifier is the stable
+   * name you chose in your AsterMD dashboard, so it can live in your
+   * configuration and survive the form being edited.
+   *
+   * @param identifier The teleform's configured identifier.
+   * @returns The teleform definition.
+   * @throws {NotFoundError} If no teleform carries that identifier.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async viewByIdentifier(identifier) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/teleforms/view-url/{form_json_identifier}",
+      pathParams: { form_json_identifier: identifier }
+    });
+  }
+  /**
+   * Fetches a teleform definition by its generated id.
+   *
+   * Use this when you already hold an id from another API response - a product's
+   * assigned teleform, for instance - rather than a configured identifier.
+   *
+   * @param id The teleform's generated id.
+   * @returns The teleform definition.
+   * @throws {NotFoundError} If the teleform does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/teleforms/view/{id}",
+      pathParams: { id }
+    });
+  }
+};
+
+// src/resource/treatments.ts
+var Treatments = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Records a treatment - an order that has been paid for.
+   *
+   * Call this only after your payment flow has settled. Include your own order
+   * identifier as `external_order_id` so the record can be reconciled against
+   * your commerce system later.
+   *
+   * @param data The order: patient, product, your order identifier, and whatever
+   *   else your configuration requires.
+   * @returns The created treatment.
+   * @throws {ValidationError} If a field is missing or rejected.
+   * @throws {NotFoundError} If the referenced patient or product does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async create(data) {
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/treatments/create",
+      body: data
+    });
+  }
+  /**
+   * Fetches one treatment, including its clinical status.
+   *
+   * This is how a storefront shows an order's progress - whether a clinician has
+   * reviewed it, whether it has shipped.
+   *
+   * @param id The treatment's id.
+   * @returns The treatment record.
+   * @throws {NotFoundError} If the treatment does not exist or is out of scope.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async view(id) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/treatments/view/{id}",
+      pathParams: { id }
+    });
+  }
+  /**
+   * Lists treatments, filtered and paginated.
+   *
+   * Useful for an account area showing a patient's order history. Pagination
+   * details come back in `meta()`; the accepted filters are in the API reference
+   * in your AsterMD dashboard.
+   *
+   * @param query Filters and pagination parameters.
+   * @returns The matching treatments, with pagination in `meta()`.
+   * @throws {ValidationError} If a filter is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async list(query = {}) {
+    return await this.transport.send({
+      service: "sales",
+      method: "GET",
+      path: "/treatments/list",
+      query
+    });
+  }
+  /**
+   * Reconciles orders placed in your own commerce system against a session.
+   *
+   * The alternative to {@link Treatments.create} for flows where checkout happens
+   * outside your storefront: hand over the session and your order identifiers and
+   * the server creates the treatments and attributes them to that session's
+   * journey. Several orders can be reconciled in one call.
+   *
+   * @param options The session, your order identifiers, and optional attribution.
+   * @returns The created treatments.
+   * @throws {ValidationError} If the session or an order identifier is rejected.
+   * @throws {NotFoundError} If the session does not exist.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async sync(options) {
+    const body = {
+      session_id: options.session,
+      order_ids: options.orderIds
+    };
+    if (options.utmSource !== void 0) {
+      body.utm_source = options.utmSource;
+    }
+    const headers = options.userAgent !== void 0 && options.userAgent !== "" ? { "User-Agent": options.userAgent } : {};
+    return await this.transport.send({
+      service: "sales",
+      method: "POST",
+      path: "/treatments/sync",
+      body,
+      headers
+    });
+  }
+};
+
+// src/resource/verification.ts
+var Verification = class extends AbstractResource {
+  /**
+   * @param transport The shared transport.
+   */
+  constructor(transport) {
+    super(transport);
+  }
+  /**
+   * Suggests complete addresses for a partial one.
+   *
+   * Built for a type-ahead: call it as the buyer types and render the
+   * suggestions. Debouncing is your side's job - every keystroke here is a round
+   * trip and counts against your request allowance.
+   *
+   * @param search The partial address typed so far.
+   * @returns Candidate addresses from the configured provider.
+   * @throws {ValidationError} If the search term is rejected.
+   * @throws {RateLimitError} If the request allowance is exceeded.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async autofillAddress(search) {
+    return await this.transport.send({
+      service: "platform",
+      method: "GET",
+      path: "/extensions/address-autofill",
+      query: { search }
+    });
+  }
+  /**
+   * Verifies that an address exists and is deliverable.
+   *
+   * Call this before checkout completes rather than after: a prescription sent to
+   * an undeliverable address is a clinical problem, not just a logistics one. The
+   * response carries the provider's normalised form of the address, which is what
+   * you should store.
+   *
+   * @param address The full address to verify.
+   * @returns The verification result and the normalised address.
+   * @throws {ValidationError} If the address is rejected.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async verifyAddress(address) {
+    return await this.transport.send({
+      service: "platform",
+      method: "GET",
+      path: "/extensions/address-verify",
+      query: { address }
+    });
+  }
+  /**
+   * Verifies that an email address is real and reachable.
+   *
+   * Catches typos and disposable addresses at the point of entry. Since every
+   * later notification - intake reminders, clinician messages, shipping updates -
+   * goes to this address, a bad one silently costs you the patient.
+   *
+   * @param email The email address to verify.
+   * @returns The verification result.
+   * @throws {ValidationError} If the address is malformed.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async verifyEmail(email) {
+    return await this.transport.send({
+      service: "platform",
+      method: "GET",
+      path: "/extensions/email-verify",
+      query: { email }
+    });
+  }
+  /**
+   * Runs an identity check against the configured provider.
+   *
+   * The strongest check available, and usually a precondition for clinical
+   * review. Which variant runs is carried by `check`, and each expects a
+   * different payload - see the API reference in your AsterMD dashboard for the
+   * fields each one needs.
+   *
+   * The payload carries PII, and a Social Security Number in the `SsnVerify`
+   * case. It is never written to a debug log, and it should not be written to
+   * yours. The payload cannot override the check you selected.
+   *
+   * @param check Which identity check to run.
+   * @param data The fields that check requires.
+   * @returns The verification result.
+   * @throws {ValidationError} If the payload does not satisfy the chosen check.
+   * @throws {ApiError} On any other non-2xx status.
+   * @throws {TransportError} If the request never completed.
+   */
+  async verifyIdentity(check, data) {
+    return await this.transport.send({
+      service: "platform",
+      method: "POST",
+      path: "/extensions/identity-verify",
+      // Data first, slug last: the caller's payload must not rewrite the check.
+      body: { ...data, slug: check }
+    });
+  }
+};
+
+// src/astermd-client.ts
+var AsterMDClient = class {
+  #config;
+  #transport;
+  #sessions;
+  #intakeSubmissions;
+  #carts;
+  #checkoutEvents;
+  #teleforms;
+  #patients;
+  #opportunities;
+  #treatments;
+  #doctorsNetworks;
+  #channels;
+  #products;
+  #categories;
+  #labTests;
+  #medications;
+  #shippings;
+  #verification;
+  #geo;
+  /**
+   * @param options Credentials, connection settings, and debug configuration.
+   * @throws {TypeError} If the credentials are empty, if `baseHost` carries a
+   *   scheme or path, if `timeoutSeconds` is below 1, or if `debug` is on with
+   *   neither `debugFile` nor `debugSink`.
+   */
+  constructor(options) {
+    const timeoutSeconds = options.timeoutSeconds ?? 10;
+    this.#config = new Config({
+      clientId: options.clientId,
+      clientSecret: options.clientSecret,
+      baseHost: options.baseHost ?? "api.astermd.com",
+      timeoutSeconds
+    });
+    let http = options.httpClient ?? new FetchHttpClient(timeoutSeconds);
+    if (options.debug === true) {
+      if (options.debugSink === void 0 && options.debugFile === void 0) {
+        throw new TypeError("debug mode requires debugFile or debugSink.");
+      }
+      const timeZone = options.debugTimezone ?? "UTC";
+      const sink = options.debugSink ?? (() => {
+        const fileSink = new DailyFileLogSink({
+          basePath: options.debugFile,
+          retentionDays: options.debugRetentionDays ?? 7,
+          timeZone
+        });
+        return async (entry) => {
+          await fileSink.write(entry);
+        };
+      })();
+      http = new LoggingHttpClient({
+        inner: http,
+        sink,
+        timeZone,
+        redactor: options.debugRedact === false ? null : new LogRedactor()
+      });
+    }
+    const urlBuilder = new UrlBuilder(this.#config.baseHost());
+    const tokenManager = new TokenManager({
+      config: this.#config,
+      httpClient: http,
+      urlBuilder,
+      store: options.tokenStore ?? new InMemoryTokenStore()
+    });
+    this.#transport = new Transport({
+      httpClient: http,
+      urlBuilder,
+      tokenProvider: async () => await tokenManager.bearerToken(),
+      onUnauthorized: async () => await tokenManager.refresh()
+    });
+  }
+  /**
+   * Returns the immutable configuration this client was built with.
+   *
+   * @returns The configuration, including {@link Config.assetUrl}.
+   */
+  config() {
+    return this.#config;
+  }
+  /**
+   * Resolves a relative asset path returned by the API against the AsterMD CDN.
+   *
+   * A convenience for `client.config().assetUrl(path)`. Treat the result as a
+   * fetch URL: download the asset once and serve your own copy rather than
+   * hot-linking.
+   *
+   * @param path Relative asset path as returned by the API.
+   * @returns The fully-qualified CDN URL.
+   */
+  assetUrl(path) {
+    return this.#config.assetUrl(path);
+  }
+  /** Sessions - the thread tying one visitor's journey together. */
+  sessions() {
+    return this.#sessions ??= new Sessions(this.#transport);
+  }
+  /** Intake submissions - pre-qualifying and intake questionnaire answers. */
+  intakeSubmissions() {
+    return this.#intakeSubmissions ??= new IntakeSubmissions(this.#transport);
+  }
+  /** Carts - what the visitor intends to buy. */
+  carts() {
+    return this.#carts ??= new Carts(this.#transport);
+  }
+  /** Checkout events - progress through the checkout funnel. */
+  checkoutEvents() {
+    return this.#checkoutEvents ??= new CheckoutEvents(this.#transport);
+  }
+  /** Teleforms - the questionnaire definitions your storefront renders. */
+  teleforms() {
+    return this.#teleforms ??= new Teleforms(this.#transport);
+  }
+  /** Patients - the person receiving care. Carries PHI. */
+  patients() {
+    return this.#patients ??= new Patients(this.#transport);
+  }
+  /** Opportunities - a named prospect worth following up. */
+  opportunities() {
+    return this.#opportunities ??= new Opportunities(this.#transport);
+  }
+  /** Treatments - the order, once payment has settled. */
+  treatments() {
+    return this.#treatments ??= new Treatments(this.#transport);
+  }
+  /** Doctors' networks - handing a case to the clinicians who review it. */
+  doctorsNetworks() {
+    return this.#doctorsNetworks ??= new DoctorsNetworks(this.#transport);
+  }
+  /** Channels - the storefront's own server-side configuration. */
+  channels() {
+    return this.#channels ??= new Channels(this.#transport);
+  }
+  /** Products - the read-only catalogue. */
+  products() {
+    return this.#products ??= new Products(this.#transport);
+  }
+  /** Categories - how the catalogue is grouped for browsing. */
+  categories() {
+    return this.#categories ??= new Categories(this.#transport);
+  }
+  /** Lab tests - diagnostic panels a product may require. */
+  labTests() {
+    return this.#labTests ??= new LabTests(this.#transport);
+  }
+  /** Medications - the reference list backing "what are you currently taking?". */
+  medications() {
+    return this.#medications ??= new Medications(this.#transport);
+  }
+  /** Shipping options - delivery methods available for an order. */
+  shippings() {
+    return this.#shippings ??= new Shippings(this.#transport);
+  }
+  /** Verification - address, email, and identity checks. */
+  verification() {
+    return this.#verification ??= new Verification(this.#transport);
+  }
+  /** Geo - where a visitor is, and whether you may serve them. */
+  geo() {
+    return this.#geo ??= new Geo(this.#transport);
+  }
+};
+
+// src/enum/event.ts
+var Event = Object.freeze({
+  /** The prospect started the pre-qualifying questionnaire. Pass to `create()`. */
+  PreQualifyingInitiated: "pre_qualifying_initiated",
+  /** The prospect advanced through an intermediate pre-qualifying step. Pass to `update()`. */
+  PreQualifyingInProgress: "pre_qualifying_inprogress",
+  /** The prospect submitted the pre-qualifying form. Pass to `update()`. */
+  PreQualifyingCompleted: "pre_qualifying_completed",
+  /** The prospect started the intake questionnaire. Pass to `create()`. */
+  IntakeInitiated: "intake_initiated",
+  /** The prospect advanced through an intermediate intake step. Pass to `update()`. */
+  IntakeInProgress: "intake_inprogress",
+  /** The prospect submitted the intake form. Pass to `update()`. */
+  IntakeCompleted: "intake_completed"
+});
+
+// src/enum/identity-check.ts
+var IdentityCheck = Object.freeze({
+  /** Cross-check the supplied identity details against the provider's records. */
+  Crosscheck: "crosscheck",
+  /** Confirm the supplied date of birth. */
+  DobVerify: "dob_verify",
+  /** Confirm the supplied Social Security Number. */
+  SsnVerify: "ssn_verify"
+});
+var FileTokenStore = class {
+  #path;
+  /**
+   * @param path Path to the JSON file used for token storage. The parent
+   *   directory is created on first write if it does not exist.
+   */
+  constructor(path) {
+    this.#path = path;
+  }
+  /**
+   * Reads the cached token from the file.
+   *
+   * @returns The stored token, or `null` when the file is absent, unreadable, or
+   *   does not hold a usable token.
+   */
+  async get() {
+    let contents;
+    try {
+      contents = await promises.readFile(this.#path, "utf8");
+    } catch {
+      return null;
+    }
+    if (contents === "") {
+      return null;
+    }
+    let decoded;
+    try {
+      decoded = JSON.parse(contents);
+    } catch {
+      return null;
+    }
+    if (typeof decoded !== "object" || decoded === null) {
+      return null;
+    }
+    const { value, expires_at: expiresAt } = decoded;
+    if (typeof value !== "string" || typeof expiresAt !== "string") {
+      return null;
+    }
+    const parsed = new Date(expiresAt);
+    if (Number.isNaN(parsed.getTime())) {
+      return null;
+    }
+    return new Token(value, parsed);
+  }
+  /**
+   * Writes the token to the backing file, replacing any existing content.
+   *
+   * Persistence is best-effort: a filesystem failure - a read-only or
+   * misconfigured cache directory, a permissions problem - is swallowed rather
+   * than thrown, matching the PHP SDK's `put()`, which returns early on a
+   * `fopen` failure. This method runs on every token acquisition, so failing it
+   * would fail the API call it was only meant to optimise; the cost of a
+   * degraded cache is an extra credential exchange next time, not a broken
+   * request.
+   *
+   * @param token The freshly acquired token to persist.
+   */
+  async put(token) {
+    const directory = path.dirname(this.#path);
+    const temporary = path.join(directory, `.${crypto.randomUUID()}.tmp`);
+    try {
+      await promises.mkdir(directory, { recursive: true, mode: 493 });
+      const contents = JSON.stringify({
+        value: token.value(),
+        expires_at: token.expiresAt().toISOString()
+      });
+      await promises.writeFile(temporary, contents, { mode: 384 });
+      await promises.rename(temporary, this.#path);
+    } catch {
+      await promises.rm(temporary, { force: true }).catch(() => void 0);
+    }
+  }
+  /**
+   * Deletes the backing file so the next {@link FileTokenStore.get} returns
+   * `null`.
+   *
+   * A no-op when the file does not exist, including when another process
+   * removed it first. Best-effort otherwise: any other filesystem failure (for
+   * example a permissions problem) is swallowed rather than thrown, since a
+   * cache that fails to clear only costs a stale-token read on the next call,
+   * which {@link FileTokenStore.get} already tolerates.
+   */
+  async clear() {
+    await promises.rm(this.#path, { force: true }).catch(() => void 0);
+  }
+};
+
+// src/presenter/channel-detail.ts
+var ChannelDetail = class {
+  constructor() {
+  }
+  /**
+   * Flattens a channel-detail payload into a shape a view can render directly.
+   *
+   * Pass `response.data()` from {@link Channels.details}. Malformed or missing
+   * branches degrade to `null` and `[]` rather than raising, because a channel is
+   * configuration a storefront needs at boot: failing the page over one absent
+   * optional field would be the wrong trade.
+   *
+   * @param data The raw `data` object from the channel-detail response.
+   * @returns The flattened view.
+   */
+  static from(data) {
+    return {
+      id: data._id ?? null,
+      name: data.name ?? null,
+      description: data.description ?? null,
+      status: data.status ?? null,
+      type: data.type ?? null,
+      auto_inc_id: data.auto_inc_id ?? null,
+      payment_processor: processor(data.payment_processor),
+      products: toList(data.products).map((entry) => product(toObject(entry)))
+    };
+  }
+};
+function processor(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const pp = value;
+  return {
+    id: pp._id ?? null,
+    name: pp.name ?? null,
+    provider: pp.provider_category ?? null,
+    type: pp.type ?? null,
+    config: pp.config ?? null
+  };
+}
+function product(entry) {
+  const byVariant = /* @__PURE__ */ new Map();
+  for (const raw of toList(entry.product_mappings)) {
+    const pm = toObject(raw);
+    const variantId = pm.variant_id;
+    if (typeof variantId === "string") {
+      byVariant.set(variantId, mapping(pm));
+    }
+  }
+  return coreProduct(toObject(entry.product), byVariant, toList(entry.add_ons));
+}
+function coreProduct(p, byVariant, addOns) {
+  const id = typeof p._id === "string" ? p._id : null;
+  const variants = toList(p.variants).map((raw) => {
+    const v = toObject(raw);
+    const variantId = typeof v._id === "string" ? v._id : null;
+    return variant(v, lookup(byVariant, variantId));
+  });
+  const singleRows = toList(p.single);
+  const single = singleRows.length === 0 ? null : singlePricing(toObject(singleRows[0]), lookup(byVariant, id));
+  return {
+    id: p._id ?? null,
+    name: p.name ?? null,
+    type: p.type ?? null,
+    sku: p.sku ?? null,
+    status: p.status ?? null,
+    visibility: p.visibility ?? null,
+    image: p.image ?? null,
+    description_long: p.description_long ?? null,
+    description_short: p.description_short ?? null,
+    restrict_multiple: p.restrict_multiple ?? null,
+    min_buy_qty: p.min_buy_qty ?? null,
+    max_buy_qty: p.max_buy_qty ?? null,
+    stock: p.stock ?? null,
+    categories: refs(p.categories),
+    condition_treated: refs(p.condition_treated),
+    teleforms: refs(p.teleforms)[0] ?? null,
+    labtest: refs(p.labtest),
+    add_ons: addOns.map((addOn) => coreProduct(toObject(addOn), /* @__PURE__ */ new Map(), [])),
+    single,
+    variants
+  };
+}
+function variant(v, productMapping) {
+  return {
+    id: v._id ?? null,
+    name: v.name ?? null,
+    sku: v.sku ?? null,
+    price: v.default_price ?? null,
+    intro_price: v.intro_price ?? null,
+    sale_price: v.sale_price ?? null,
+    sale_start: v.sale_start ?? null,
+    sale_end: v.sale_end ?? null,
+    mapping: productMapping
+  };
+}
+function singlePricing(row, productMapping) {
+  return {
+    price: row.default_price ?? null,
+    intro_price: row.intro_price ?? null,
+    sale_price: row.sale_price ?? null,
+    sale_start: row.sale_start ?? null,
+    sale_end: row.sale_end ?? null,
+    mapping: productMapping
+  };
+}
+function mapping(pm) {
+  const integration = toObject(pm.integration);
+  const out = { type: integration.type ?? null };
+  for (const [key, value] of Object.entries(toObject(pm.mapping))) {
+    if (key !== "type") {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function refs(list) {
+  return toList(list).map((item) => ref(item));
+}
+function ref(r) {
+  if (typeof r !== "object" || r === null) {
+    return r;
+  }
+  const raw = r;
+  const out = { id: raw._id ?? null };
+  for (const [key, value] of Object.entries(raw)) {
+    if (key !== "_id") {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function lookup(map, key) {
+  return key === null ? null : map.get(key) ?? null;
+}
+function toList(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return typeof value === "object" && value !== null ? Object.values(value) : [];
+}
+function toObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+var ALGORITHM = "aes-128-cbc";
+var IV_LENGTH = 16;
+var QueryParamCipher = class {
+  constructor() {
+  }
+  /**
+   * Decrypts a query-parameter token into tracking parameters.
+   *
+   * Call this at your storefront's entry point with the raw token from the URL
+   * and the key from your own configuration. Any failure along the way - bad
+   * encoding, wrong or malformed key, decryption error, non-list payload -
+   * returns an empty object so the caller can fall back to plain parameters.
+   *
+   * @param token The base64url token, `iv(16) || ciphertext`.
+   * @param keyHex 32 hex characters - a 16-byte AES-128 key. Supplied by you;
+   *   the SDK ships no default.
+   * @returns The decrypted parameters, or `{}` on any failure.
+   */
+  static decrypt(token, keyHex) {
+    if (token === "" || keyHex === "") {
+      return {};
+    }
+    const key = decodeKey(keyHex);
+    if (key === null) {
+      return {};
+    }
+    let blob;
+    try {
+      blob = Buffer.from(base64UrlToBase64(token), "base64");
+    } catch {
+      return {};
+    }
+    if (blob.byteLength <= IV_LENGTH) {
+      return {};
+    }
+    let json;
+    try {
+      const decipher = crypto.createDecipheriv(ALGORITHM, key, blob.subarray(0, IV_LENGTH));
+      json = Buffer.concat([decipher.update(blob.subarray(IV_LENGTH)), decipher.final()]).toString("utf8");
+    } catch {
+      return {};
+    }
+    let decoded;
+    try {
+      decoded = JSON.parse(json);
+    } catch {
+      return {};
+    }
+    if (!Array.isArray(decoded)) {
+      return {};
+    }
+    const out = {};
+    for (const entry of decoded) {
+      if (typeof entry !== "object" || entry === null) {
+        continue;
+      }
+      const { key: name, value } = entry;
+      if (!isScalar(name)) {
+        continue;
+      }
+      out[phpString(name)] = isScalar(value) ? phpString(value) : "";
+    }
+    return out;
+  }
+  /**
+   * Encrypts tracking parameters into a token.
+   *
+   * Provided mainly for round-trip tests and local tooling. A fresh random IV is
+   * generated on every call and prepended to the ciphertext before encoding, so
+   * the same parameters never produce the same token twice.
+   *
+   * Unlike {@link QueryParamCipher.decrypt}, this is strict: a bad key raises
+   * rather than being swallowed, because a failed encrypt is a programming error
+   * and not untrusted input.
+   *
+   * @param params The parameters to encrypt. Written to the wire as the
+   *   `[{ key, value }, …]` list the PHP SDK also reads.
+   * @param keyHex 32 hex characters - a 16-byte AES-128 key.
+   * @returns The base64url token, `iv(16) || ciphertext`.
+   * @throws {TypeError} If `keyHex` is not a valid 16-byte hex key.
+   */
+  static encrypt(params, keyHex) {
+    const key = decodeKey(keyHex);
+    if (key === null) {
+      throw new TypeError("keyHex must be 32 hex chars (a 16-byte AES-128 key).");
+    }
+    const payload = JSON.stringify(Object.entries(params).map(([name, value]) => ({ key: name, value })));
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    const ciphertext = Buffer.concat([cipher.update(payload, "utf8"), cipher.final()]);
+    return Buffer.concat([iv, ciphertext]).toString("base64url");
+  }
+};
+function decodeKey(keyHex) {
+  if (!/^[0-9a-fA-F]{32}$/.test(keyHex)) {
+    return null;
+  }
+  return Buffer.from(keyHex, "hex");
+}
+function base64UrlToBase64(value) {
+  const standard = value.replaceAll("-", "+").replaceAll("_", "/");
+  const remainder = standard.length % 4;
+  return remainder === 0 ? standard : standard + "=".repeat(4 - remainder);
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function phpString(value) {
+  if (typeof value === "boolean") {
+    return value ? "1" : "";
+  }
+  return String(value);
+}
+
+exports.AbstractResource = AbstractResource;
+exports.ApiError = ApiError;
+exports.AsterMDClient = AsterMDClient;
+exports.AsterMDError = AsterMDError;
+exports.AuthenticationError = AuthenticationError;
+exports.Carts = Carts;
+exports.Categories = Categories;
+exports.ChannelDetail = ChannelDetail;
+exports.Channels = Channels;
+exports.CheckoutEvent = CheckoutEvent;
+exports.CheckoutEvents = CheckoutEvents;
+exports.Config = Config;
+exports.DailyFileLogSink = DailyFileLogSink;
+exports.DoctorsNetworks = DoctorsNetworks;
+exports.Event = Event;
+exports.FetchHttpClient = FetchHttpClient;
+exports.FileTokenStore = FileTokenStore;
+exports.FileUpload = FileUpload;
+exports.Geo = Geo;
+exports.IdentityCheck = IdentityCheck;
+exports.InMemoryTokenStore = InMemoryTokenStore;
+exports.IntakeSubmissions = IntakeSubmissions;
+exports.LabTests = LabTests;
+exports.Medications = Medications;
+exports.NotFoundError = NotFoundError;
+exports.Opportunities = Opportunities;
+exports.Patients = Patients;
+exports.Products = Products;
+exports.QueryParamCipher = QueryParamCipher;
+exports.RateLimitError = RateLimitError;
+exports.Response = Response2;
+exports.Sessions = Sessions;
+exports.Shippings = Shippings;
+exports.Teleforms = Teleforms;
+exports.Token = Token;
+exports.TransportError = TransportError;
+exports.Treatments = Treatments;
+exports.ValidationError = ValidationError;
+exports.Verification = Verification;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map