@astermd-hq/sdk 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,2825 @@
+/**
+ * Immutable value object holding a JWT bearer token and its server-stated
+ * expiry.
+ *
+ * {@link TokenManager} builds one after a successful credential exchange and
+ * hands it to a {@link TokenStore}. Before each request the manager calls
+ * {@link Token.isExpired} to decide whether the cached token can be reused or a
+ * fresh one must be acquired.
+ *
+ * The organisation the token authorises is encoded inside the JWT itself, which
+ * is why no SDK method takes an organisation argument.
+ */
+declare class Token {
+    #private;
+    /**
+     * @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: string, expiresAt: Date);
+    /**
+     * Returns the raw JWT string.
+     *
+     * @returns The JWT, ready for use as a bearer credential.
+     */
+    value(): string;
+    /**
+     * 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(): Date;
+    /**
+     * 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?: number): boolean;
+}
+
+/**
+ * Pluggable persistence for the bearer token.
+ *
+ * The default is {@link InMemoryTokenStore}, which caches the token for the life
+ * of the process. That is the right choice for a long-lived server. It is the
+ * wrong choice when every request runs in a fresh process or isolate - a
+ * serverless function, for instance - because each one would then perform its own
+ * credential exchange. {@link FileTokenStore} covers the single-machine case, and
+ * this interface covers everything else.
+ *
+ * Every method is asynchronous so a store can talk to a remote system:
+ *
+ * ```ts
+ * class RedisTokenStore implements TokenStore {
+ *   constructor(private readonly redis: MyRedisClient) {}
+ *
+ *   async get(): Promise<Token | null> {
+ *     const raw = await this.redis.get('astermd:token');
+ *     if (raw === null) return null;
+ *     const { value, expiresAt } = JSON.parse(raw);
+ *     return new Token(value, new Date(expiresAt));
+ *   }
+ *
+ *   async put(token: Token): Promise<void> {
+ *     await this.redis.set(
+ *       'astermd:token',
+ *       JSON.stringify({ value: token.value(), expiresAt: token.expiresAt() }),
+ *     );
+ *   }
+ *
+ *   async clear(): Promise<void> {
+ *     await this.redis.del('astermd:token');
+ *   }
+ * }
+ * ```
+ *
+ * A stored token is a live credential. Whatever backs the store must be as
+ * protected as the client secret itself.
+ */
+interface TokenStore {
+    /**
+     * Returns the cached token, or `null` when there is none.
+     *
+     * Expiry is not this method's concern - {@link TokenManager} checks it. A store
+     * should return whatever it holds and treat unreadable or corrupt state as
+     * absence rather than raising.
+     *
+     * @returns The stored token, or `null`.
+     */
+    get(): Promise<Token | null>;
+    /**
+     * Stores a freshly acquired token, replacing any previous one.
+     *
+     * @param token The token to persist.
+     */
+    put(token: Token): Promise<void>;
+    /**
+     * Discards the stored token so the next {@link TokenStore.get} returns `null`.
+     *
+     * Called when the server rejects the current token, before a fresh one is
+     * acquired.
+     */
+    clear(): Promise<void>;
+}
+
+/** Options accepted by {@link Config}. */
+interface ConfigOptions {
+    /** OAuth2 client ID issued by AsterMD. Must be non-empty. */
+    clientId: string;
+    /** OAuth2 client secret corresponding to `clientId`. Must be non-empty. */
+    clientSecret: string;
+    /** Bare API hostname without scheme or path. Defaults to `api.astermd.com`. */
+    baseHost?: string;
+    /** Per-request timeout in seconds. Must be >= 1. Defaults to 10. */
+    timeoutSeconds?: number;
+}
+/**
+ * Immutable value object holding SDK configuration.
+ *
+ * Stores the OAuth2 credentials and connection settings every outbound request
+ * needs. It is constructed once inside {@link AsterMDClient} and never mutated.
+ * Validation happens eagerly in the constructor, so a misconfigured client fails
+ * at boot rather than at its first network call.
+ *
+ * `baseHost` is a bare hostname. The SDK always prepends `https://` and appends
+ * `/v1/{service}/{path}` itself - never pass a full URL.
+ */
+declare class Config {
+    #private;
+    /**
+     * @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: ConfigOptions);
+    /**
+     * Returns the OAuth2 client ID used to acquire JWT bearer tokens.
+     *
+     * @returns The client ID, guaranteed non-empty.
+     */
+    clientId(): string;
+    /**
+     * Returns the OAuth2 client secret used to acquire JWT bearer tokens.
+     *
+     * @returns The client secret, guaranteed non-empty.
+     */
+    clientSecret(): string;
+    /**
+     * 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(): string;
+    /**
+     * 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(): number;
+    /**
+     * 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: string): string;
+}
+
+/**
+ * The SDK's HTTP injection seam: one method, taking a platform `Request` and
+ * returning a platform `Response`.
+ *
+ * The default implementation is {@link FetchHttpClient}, which wraps the global
+ * `fetch`. Supplying your own is how you route SDK traffic through a proxy
+ * agent, add your own retry policy, pin TLS settings, or stub the network out in
+ * tests:
+ *
+ * ```ts
+ * class ProxiedHttpClient implements HttpClient {
+ *   async sendRequest(request: Request): Promise<Response> {
+ *     return await fetch(request, { dispatcher: myProxyAgent });
+ *   }
+ * }
+ *
+ * const client = new AsterMDClient({
+ *   clientId: process.env.ASTERMD_CLIENT_ID!,
+ *   clientSecret: process.env.ASTERMD_CLIENT_SECRET!,
+ *   httpClient: new ProxiedHttpClient(),
+ * });
+ * ```
+ *
+ * An implementation should let a network-level failure surface as
+ * {@link TransportError}. {@link Transport} wraps anything else this throws
+ * into a {@link TransportError} as well, so every error reaching a caller of
+ * the SDK still extends {@link AsterMDError} - but that is a safety net, not
+ * licence to throw arbitrary values: prefer throwing {@link TransportError}
+ * directly, or an {@link AsterMDError} subclass, so the original error type is
+ * preserved rather than rewrapped.
+ *
+ * The debug logger is itself an implementation of this interface that decorates
+ * another one, which is how a single seam covers both API traffic and the
+ * credential exchange.
+ */
+interface HttpClient {
+    /**
+     * Sends one request and resolves with the response.
+     *
+     * @param request The fully-built request, including URL, method, headers, and
+     *                body. Implementations must not mutate it.
+     * @returns The response as received. A non-2xx status is a normal return, not
+     *          an error - {@link Transport} maps statuses to errors.
+     * @throws {TransportError} On a network-level failure, where no response
+     *   arrived.
+     */
+    sendRequest(request: Request): Promise<Response>;
+}
+
+/**
+ * Destination for debug log entries.
+ *
+ * Called once per request with a fully formatted entry - timestamp, curl
+ * command, and response. Return a promise to have the SDK await the write. Any
+ * error it throws is swallowed: a failing log must never fail an API call.
+ */
+type DebugSink = (entry: string) => void | Promise<void>;
+
+/** Options accepted by {@link Response}. */
+interface ResponseOptions<T> {
+    /** HTTP status code of the response (200–299). */
+    statusCode: number;
+    /** Contents of the envelope's `data` key. */
+    data: T;
+    /** Contents of the envelope's `meta` key; may be empty. */
+    meta: Record<string, unknown>;
+    /** Human-readable `message` string from the envelope. */
+    message: string;
+    /** Raw response body, before decoding. */
+    raw: string;
+}
+/**
+ * Value object representing a successful API response with its envelope
+ * already decoded.
+ *
+ * Every AsterMD response that returns HTTP 2xx is wrapped in a standard JSON
+ * envelope:
+ *
+ * ```json
+ * { "success": true, "message": "Record created.", "data": { }, "meta": { } }
+ * ```
+ *
+ * {@link Transport} decodes that envelope and builds a `Response` from it.
+ * `data()` holds the primary resource payload - `{ session: "<uuid>" }` for
+ * session creation, for instance - while `meta()` carries pagination cursors and
+ * other out-of-band information where the endpoint emits them.
+ *
+ * Non-2xx responses are never wrapped in this object; they raise
+ * {@link ApiError} or one of its subclasses instead.
+ *
+ * The shape of `data()` varies by endpoint, so it defaults to an untyped record.
+ * A caller who knows the shape may narrow it:
+ *
+ * ```ts
+ * const patient = await client.patients().view<Patient>('p-1');
+ * ```
+ *
+ * The instance and its top-level `data`/`meta` objects are frozen, which guards
+ * against accidental reassignment or a stray `delete` on this response. That
+ * freeze is shallow, though: an object or array nested inside `data()` is the
+ * server's payload passed through unchanged, and remains as mutable as any
+ * other object you receive from `JSON.parse`. Treat nested values as you would
+ * any other deserialised response - copy before mutating if that matters to
+ * you - rather than relying on this class to protect them.
+ */
+declare class Response$1<T = Record<string, unknown>> {
+    #private;
+    /**
+     * @param options The decoded envelope fields.
+     */
+    constructor(options: ResponseOptions<T>);
+    /**
+     * Returns the HTTP status code, always 200–299 for a `Response` instance.
+     *
+     * @returns The status code, e.g. `200` or `201`.
+     */
+    statusCode(): number;
+    /**
+     * 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(): T;
+    /**
+     * 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(): Readonly<Record<string, unknown>>;
+    /**
+     * 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(): string;
+    /**
+     * 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(): string;
+}
+
+/** Overrides accepted by {@link FileUpload.fromPath}. */
+interface FileUploadFromPathOptions {
+    /** Name to send in the part header. Defaults to the path's base name. */
+    fileName?: string;
+    /** MIME type to send. Defaults to one derived from the extension. */
+    mimeType?: string;
+}
+/** Overrides accepted by {@link FileUpload.fromContents}. */
+interface FileUploadFromContentsOptions {
+    /** MIME type to send. Defaults to one derived from the file name. */
+    mimeType?: string;
+}
+/**
+ * An immutable file, in memory, ready to be sent as a `multipart/form-data`
+ * part.
+ *
+ * A handful of AsterMD endpoints take bytes rather than JSON - the
+ * intake-submission file endpoints on the `sales` service are the current
+ * example. Those bytes come from very different places: a file your users just
+ * uploaded and that now sits on local disk, or a slice of a large file being fed
+ * through the multipart flow one chunk at a time. This class is the single shape
+ * resource methods accept for both, so {@link Transport} has exactly one thing
+ * to encode.
+ *
+ * Build it through one of the two factories - the constructor is private, so an
+ * instance always carries a file name and a MIME type:
+ *
+ * ```ts
+ * // From a file on disk; name and MIME type come from the path.
+ * await client.intakeSubmissions().uploadFile(
+ *   sessionId,
+ *   await FileUpload.fromPath('/var/uploads/id-front.jpg'),
+ * );
+ *
+ * // From bytes already in memory: one 10 MB slice of a large video.
+ * await client.intakeSubmissions().uploadMultipartPart({
+ *   uploadId,
+ *   partNumber: 1,
+ *   part: FileUpload.fromContents(chunk, 'consult-video.mp4'),
+ * });
+ * ```
+ *
+ * The whole file is held in memory, so it is deliberately not the right tool for
+ * a 200 MB video - use {@link IntakeSubmissions.uploadLargeFile}, which streams
+ * from disk and only ever materialises one part at a time.
+ *
+ * File names are normalised on construction: directory components are dropped
+ * and quote, backslash, and newline characters removed, so a caller-supplied
+ * name can never break out of the header it is written into.
+ */
+declare class FileUpload {
+    #private;
+    private constructor();
+    /**
+     * 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 fromPath(path: string, options?: FileUploadFromPathOptions): Promise<FileUpload>;
+    /**
+     * 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: Uint8Array, fileName: string, options?: FileUploadFromContentsOptions): FileUpload;
+    /**
+     * Returns the raw bytes that will form the body of the multipart part.
+     *
+     * @returns The file's contents.
+     */
+    contents(): Uint8Array;
+    /**
+     * 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(): string;
+    /**
+     * Returns the MIME type sent for the part.
+     *
+     * @returns The MIME type, e.g. `image/jpeg`.
+     */
+    mimeType(): string;
+    /**
+     * 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(): number;
+}
+
+/** Query string parameters accepted by {@link UrlBuilder.build}. */
+type QueryParams = Record<string, string | number | boolean>;
+/**
+ * Builds fully-qualified HTTPS request URLs following the `/v1/{service}/{path}`
+ * convention.
+ *
+ * Every AsterMD endpoint lives under `https://{host}/v1/{service}/{path}`, where
+ * `{service}` is `auth`, `sales`, or `platform`. This class is the one place that
+ * convention is encoded, so resources never construct URLs and the SDK can never
+ * be handed a full URL by a consumer.
+ *
+ * Path placeholders such as `{id}` are substituted and percent-encoded; query
+ * parameters are appended with PHP-compatible encoding so a URL built here is
+ * byte-identical to the one the PHP SDK would build for the same call.
+ */
+declare class UrlBuilder {
+    #private;
+    /**
+     * @param baseHost Bare hostname to prepend, e.g. `api.astermd.com`.
+     */
+    constructor(baseHost: string);
+    /**
+     * 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: string, path: string, pathParams?: Record<string, string | number>, query?: QueryParams): string;
+}
+
+/** One outbound API call, described declaratively. */
+interface SendOptions {
+    /** Service segment of the URL: `sales`, `auth`, or `platform`. */
+    service: string;
+    /** HTTP method in uppercase. */
+    method: string;
+    /** Path relative to `/v1/{service}`, with `{placeholder}` tokens. */
+    path: string;
+    /** Placeholder name → value, substituted into `path`. */
+    pathParams?: Record<string, string | number>;
+    /** Query string parameters. */
+    query?: QueryParams;
+    /**
+     * Request body, serialised as JSON. An empty object is sent as `{}`, which
+     * every AsterMD endpoint requires of an object-shaped body. Omit for no body.
+     * Mutually exclusive with `file`.
+     */
+    body?: Record<string, unknown> | null;
+    /** Additional headers, e.g. `x-phi-verification-token`. */
+    headers?: Record<string, string>;
+    /**
+     * File to send as a `multipart/form-data` body under the field name `file`.
+     * Mutually exclusive with `body`.
+     */
+    file?: FileUpload | null;
+}
+/** Collaborators {@link Transport} needs. */
+interface TransportOptions {
+    /** The client all outbound calls go through. */
+    httpClient: HttpClient;
+    /** Builds request URLs. */
+    urlBuilder: UrlBuilder;
+    /**
+     * Returns the current bearer token, or `null` for an unauthenticated request.
+     * {@link TokenManager} passes a provider that always returns `null` for its own
+     * credential exchange, which is what stops that call recursing.
+     */
+    tokenProvider: () => Promise<string | null>;
+    /**
+     * Invoked at most once per `send()` when the server answers 401. Should
+     * refresh the token and resolve `true` to request a replay, or `false` to let
+     * the 401 surface.
+     */
+    onUnauthorized: () => Promise<boolean>;
+}
+/**
+ * The single HTTP chokepoint for every outbound API call.
+ *
+ * Each resource method delegates to {@link Transport.send}, which owns the whole
+ * request lifecycle: URL construction, bearer-token attachment, request
+ * building, body serialisation, dispatch through the {@link HttpClient} seam,
+ * envelope decoding, and the mapping from HTTP status to error class. Resources
+ * never see a `Request`, a `Response`, or a line of JSON - that separation is
+ * what keeps seventeen resource classes trivial and testable.
+ *
+ * The 401-retry protocol is built in. On a 401 the transport calls
+ * `onUnauthorized` once, which in the production wiring refreshes the token, and
+ * replays the request if that resolves `true`. A second 401 raises
+ * {@link AuthenticationError} with no further retry.
+ *
+ * Status mapping:
+ *
+ * - 200–299 → {@link Response} with the envelope decoded
+ * - 401 → {@link AuthenticationError}
+ * - 404 → {@link NotFoundError}
+ * - 422 → {@link ValidationError}, with field errors extracted from `errors`
+ * - 429 → {@link RateLimitError}, with `Retry-After` parsed when present
+ * - anything else → {@link ApiError}
+ * - no response at all → {@link TransportError}, from the {@link HttpClient}
+ */
+declare class Transport {
+    #private;
+    /**
+     * @param options The collaborators to use for every call.
+     */
+    constructor(options: TransportOptions);
+    /**
+     * 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.
+     */
+    send<T = Record<string, unknown>>(options: SendOptions): Promise<Response$1<T>>;
+}
+
+/**
+ * Base class for every SDK resource; holds the shared {@link Transport}.
+ *
+ * Resource classes extend this and call `this.transport.send()` to dispatch every
+ * outbound request. A resource never builds a request, touches a header, or
+ * decodes JSON - all of that belongs to `Transport` alone. That is what keeps
+ * seventeen resource classes small enough to read at a glance and testable
+ * without a network.
+ */
+declare abstract class AbstractResource {
+    /** The shared transport used for all outbound API calls. */
+    protected readonly transport: Transport;
+    /**
+     * @param transport The transport every call from this resource goes through.
+     */
+    protected constructor(transport: Transport);
+}
+
+/** Options for {@link Carts.create} and {@link Carts.update}. */
+interface CartWriteOptions {
+    /** The session the cart belongs to. */
+    session: string;
+    /**
+     * The cart's full contents. Each entry identifies a product and quantity, and
+     * a variant where the product has them. This is the complete list, not a
+     * delta - see the API reference in your AsterMD dashboard for the fields.
+     */
+    items: Record<string, unknown>[];
+}
+/**
+ * Carts - what the visitor intends to buy, recorded against their session.
+ *
+ * The cart is a server-side record of intent, kept so abandonment can be measured
+ * and so the eventual order can be reconciled against what was selected. It is
+ * not a pricing engine and not a checkout: money is handled by your own payment
+ * flow, and the resulting order arrives through
+ * {@link Treatments.create} or {@link Treatments.sync}.
+ *
+ * Both methods take the cart's *whole* contents rather than a delta. Mirror your
+ * storefront's cart state into `update()` whenever it changes, and the
+ * server-side record stays in step with what the visitor is actually looking at.
+ */
+declare class Carts extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(options: CartWriteOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(options: CartWriteOptions): Promise<Response$1<T>>;
+}
+
+/**
+ * Categories - how the catalogue is grouped for browsing.
+ *
+ * A category is a merchandising grouping a storefront renders as navigation: a
+ * condition treated, a product family, a landing-page collection. Products
+ * reference the categories they belong to, so fetching the category list is
+ * usually the first call a catalogue page makes.
+ *
+ * Read-only, and configured in your AsterMD dashboard.
+ */
+declare class Categories extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Channels - the storefront's own configuration, as the server holds it.
+ *
+ * A channel is one selling surface: a brand, a site, a campaign landing page.
+ * Which products it may sell, which payment processor it uses, and which
+ * questionnaires those products require are all channel-level configuration set
+ * in your AsterMD dashboard. Your storefront reads that configuration rather than
+ * duplicating it, so changing what a brand sells does not need a deployment.
+ *
+ * Three views, in increasing depth. {@link Channels.view} returns the channel
+ * itself. {@link Channels.assignedProducts} returns what it may sell.
+ * {@link Channels.details} returns the whole tree - channel, payment processor,
+ * products, variants, prices, and per-integration mappings - in a single call,
+ * which is what a storefront usually wants at boot.
+ *
+ * Channel configuration changes rarely. Fetch it rather than embedding a copy,
+ * but caching the result for minutes is reasonable.
+ */
+declare class Channels extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    assignedProducts<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    details<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Checkout-funnel events recorded against a session.
+ *
+ * {@link CheckoutEvents.create} always records `CheckoutVisited` - it is the
+ * call that opens the funnel record. Every later state is reported through
+ * {@link CheckoutEvents.update} with one of the remaining values, which lets the
+ * server reconstruct where a prospect abandoned checkout and which upsells they
+ * were shown.
+ */
+declare const CheckoutEvent: Readonly<{
+    /** The prospect reached the checkout page. Recorded implicitly by `create()`. */
+    readonly CheckoutVisited: "checkout_visited";
+    /** An upsell was presented to the prospect. */
+    readonly UpsellOffered: "upsell_offered";
+    /** The prospect accepted a presented upsell. */
+    readonly UpsellAccepted: "upsell_accepted";
+    /** The prospect declined a presented upsell. */
+    readonly UpsellDeclined: "upsell_declined";
+    /** The order was placed successfully. */
+    readonly OrderPlaced: "order_placed";
+    /** The order was declined, typically by the payment processor. */
+    readonly OrderDeclined: "order_declined";
+}>;
+/** Any checkout-funnel event wire value. A bare string literal satisfies this type. */
+type CheckoutEvent = (typeof CheckoutEvent)[keyof typeof CheckoutEvent];
+
+/** Options for {@link CheckoutEvents.update}. */
+interface CheckoutEventUpdateOptions {
+    /** The session whose checkout record is being advanced. */
+    session: string;
+    /** The funnel state now reached. */
+    event: CheckoutEvent;
+    /**
+     * Additional context for this event - which upsell was shown, the order total,
+     * a decline reason. Forwarded unmodified except that it can never override
+     * `event`.
+     */
+    data?: Record<string, unknown>;
+}
+/**
+ * Checkout events - the visitor's progress through the checkout funnel.
+ *
+ * Where {@link Sessions} records that a visit happened and {@link Carts} records
+ * what was selected, this resource records what happened at the till: the
+ * checkout page opening, each upsell offered and accepted or declined, and
+ * finally whether the order was placed or declined. Together those events are
+ * what makes checkout abandonment measurable.
+ *
+ * {@link CheckoutEvents.create} opens the record and always registers
+ * `checkout_visited`; every later state goes through
+ * {@link CheckoutEvents.update} with the matching {@link CheckoutEvent}. Neither
+ * call can have its event overridden by the extra payload, so the funnel state
+ * the server records is always the one the SDK's caller chose explicitly.
+ */
+declare class CheckoutEvents extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(session: string, data?: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(options: CheckoutEventUpdateOptions): Promise<Response$1<T>>;
+}
+
+/**
+ * Doctors' networks - handing a case to the clinicians who will review it.
+ *
+ * A doctors' network is the panel of licensed clinicians configured for your
+ * organisation. Syncing pushes a case to that panel so a clinician can pick it
+ * up: it is the bridge between the commercial half of the order flow and the
+ * clinical one.
+ *
+ * The single method here is unusual in the SDK for validating before it sends. A
+ * sync with neither an opportunity to attach to nor enough detail to identify the
+ * person would be accepted by the transport and rejected by the server, having
+ * cost a round trip to learn something the SDK can see locally. So it checks
+ * first, and raises `TypeError` rather than making the call.
+ *
+ * ```ts
+ * await client.doctorsNetworks().sync({ opportunity_id: opportunityId });
+ *
+ * // or, without an opportunity yet:
+ * await client.doctorsNetworks().sync({
+ *   user_info: { first_name: 'Jane', email: 'jane@example.test' },
+ * });
+ * ```
+ */
+declare class DoctorsNetworks extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    sync<T = Record<string, unknown>>(payload: Record<string, unknown>): Promise<Response$1<T>>;
+}
+
+/**
+ * Geo - where a visitor is, and whether you are allowed to serve them.
+ *
+ * Telehealth is licensed jurisdiction by jurisdiction, so location is not a
+ * personalisation detail here - it decides whether an order flow may start at
+ * all. These two endpoints answer the two different questions that follow from
+ * that.
+ *
+ * {@link Geo.info} resolves an IP address to a location, which is what you want
+ * for pre-filling a state selector or routing a visitor to the right regional
+ * content. {@link Geo.blocklist} answers the narrower question of whether this
+ * address is barred - a jurisdiction you are not licensed in, a known proxy or
+ * anonymiser. Check the blocklist at the top of the funnel: turning a visitor
+ * away on the landing page is far cheaper than doing it after they have completed
+ * an intake questionnaire.
+ *
+ * Pass the *visitor's* address, not your server's. Behind a proxy or load
+ * balancer that means reading the forwarded-for header your infrastructure sets,
+ * with the same care you would apply anywhere else - that header is
+ * caller-supplied unless your edge overwrites it.
+ *
+ * Both take their input as a query parameter, and redaction never covers the URL,
+ * so a debug entry for these calls contains the IP address that was checked.
+ */
+declare class Geo extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    info<T = Record<string, unknown>>(ip: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    blocklist<T = Record<string, unknown>>(ip: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Journey events recorded alongside intake-submission records.
+ *
+ * Every call to {@link IntakeSubmissions.create} or
+ * {@link IntakeSubmissions.update} must carry one of these events to advance the
+ * server-side order-flow state machine.
+ *
+ * Two separate flows exist, each with three events.
+ *
+ * Pre-qualifying flow - emitted while the prospect answers eligibility
+ * questions:
+ * - `PreQualifyingInitiated` → first form step (use with `create()`)
+ * - `PreQualifyingInProgress` → intermediate steps (use with `update()`)
+ * - `PreQualifyingCompleted` → final step / form submitted (use with `update()`)
+ *
+ * Intake flow - emitted while the prospect fills in the full intake
+ * questionnaire:
+ * - `IntakeInitiated` → first form step (use with `create()`)
+ * - `IntakeInProgress` → intermediate steps (use with `update()`)
+ * - `IntakeCompleted` → final step / form submitted (use with `update()`)
+ *
+ * In both flows the `*Initiated` event always goes to `create()`, the call that
+ * creates the server-side record, and the `*InProgress` / `*Completed` events go
+ * to subsequent `update()` calls.
+ */
+declare const Event: Readonly<{
+    /** The prospect started the pre-qualifying questionnaire. Pass to `create()`. */
+    readonly PreQualifyingInitiated: "pre_qualifying_initiated";
+    /** The prospect advanced through an intermediate pre-qualifying step. Pass to `update()`. */
+    readonly PreQualifyingInProgress: "pre_qualifying_inprogress";
+    /** The prospect submitted the pre-qualifying form. Pass to `update()`. */
+    readonly PreQualifyingCompleted: "pre_qualifying_completed";
+    /** The prospect started the intake questionnaire. Pass to `create()`. */
+    readonly IntakeInitiated: "intake_initiated";
+    /** The prospect advanced through an intermediate intake step. Pass to `update()`. */
+    readonly IntakeInProgress: "intake_inprogress";
+    /** The prospect submitted the intake form. Pass to `update()`. */
+    readonly IntakeCompleted: "intake_completed";
+}>;
+/** Any journey event wire value. A bare string literal satisfies this type. */
+type Event = (typeof Event)[keyof typeof Event];
+
+/** Options for {@link IntakeSubmissions.view}. */
+interface IntakeViewOptions {
+    /** The intake submission's id. */
+    id: string;
+    /** The teleform the submission answers. */
+    teleformId: string;
+}
+/** Options for {@link IntakeSubmissions.create} and {@link IntakeSubmissions.update}. */
+interface IntakeWriteOptions {
+    /** The session the submission belongs to. */
+    session: string;
+    /** The journey event this call records. */
+    event: Event;
+    /** The teleform being answered. */
+    teleformId: string;
+    /**
+     * The answers, one entry per field: `{ id, name, label, type, value }`, where
+     * `value` is itself a list of `{ value }` entries so a multi-select field can
+     * carry several. Send every answer collected so far, not only what changed.
+     */
+    data: Record<string, unknown>[];
+    /**
+     * Optional progress information for a partially completed form, e.g.
+     * `{ current_step, total_steps }`. Lets the server report how far a prospect
+     * got before abandoning.
+     */
+    progress?: Record<string, unknown>;
+}
+/** Options for {@link IntakeSubmissions.uploadFile}. */
+interface UploadFileOptions {
+    /** The session the file belongs to. */
+    sessionId: string;
+    /** The file to upload. */
+    file: FileUpload;
+}
+/** Options for {@link IntakeSubmissions.initiateMultipartUpload}. */
+interface InitiateMultipartOptions {
+    /** The session the file belongs to. */
+    sessionId: string;
+    /** Name to store the file under. */
+    fileName: string;
+    /** MIME type of the whole file. */
+    mimeType: string;
+    /** Total size of the whole file in bytes, not of one part. */
+    fileSize: number;
+}
+/** Options for {@link IntakeSubmissions.uploadMultipartPart}. */
+interface UploadPartOptions {
+    /** The upload id returned by initiate. */
+    uploadId: string;
+    /** 1-based part number, between 1 and 10000. */
+    partNumber: number;
+    /** The bytes of this part. */
+    part: FileUpload;
+}
+/** One uploaded part, as {@link IntakeSubmissions.finishMultipartUpload} expects it. */
+interface MultipartPart {
+    /** The part number that was uploaded. */
+    part_number: number;
+    /** The etag the server returned for that part. */
+    etag: string;
+}
+/** Options for {@link IntakeSubmissions.finishMultipartUpload}. */
+interface FinishMultipartOptions {
+    /** The upload id returned by initiate. */
+    uploadId: string;
+    /** Every uploaded part with its etag, in order. Must not be empty. */
+    parts: MultipartPart[];
+}
+/** Options for {@link IntakeSubmissions.uploadLargeFile}. */
+interface UploadLargeFileOptions {
+    /** The session the file belongs to. */
+    sessionId: string;
+    /** Path to the file on local disk. */
+    filePath: string;
+    /** Name to store the file under. Defaults to the path's base name. */
+    fileName?: string;
+    /** MIME type to send. Defaults to one derived from the file name. */
+    mimeType?: string;
+    /**
+     * Bytes per part. Must be between {@link IntakeSubmissions.MIN_PART_SIZE} and
+     * {@link IntakeSubmissions.MAX_PART_SIZE}. Defaults to
+     * {@link IntakeSubmissions.DEFAULT_PART_SIZE}.
+     */
+    partSize?: number;
+}
+/**
+ * Intake submissions - the answers a prospect gives to your questionnaires.
+ *
+ * This is where the clinical part of the order flow happens. Two questionnaires
+ * run through this one resource: the short pre-qualifying form that decides
+ * whether a prospect is eligible at all, and the full intake questionnaire a
+ * clinician later reviews. Which one a call belongs to is carried entirely by the
+ * {@link Event} it passes.
+ *
+ * Both follow the same rhythm. The `*Initiated` event goes to
+ * {@link IntakeSubmissions.create}, which creates the server-side record. Every
+ * later step goes to {@link IntakeSubmissions.update} with `*InProgress`, and the
+ * final submission with `*Completed`. Sending progress updates as the prospect
+ * moves through the form is what makes partial completion visible instead of
+ * looking like an abandoned session:
+ *
+ * ```ts
+ * await client.intakeSubmissions().create({
+ *   session,
+ *   event: Event.IntakeInitiated,
+ *   teleformId,
+ *   data: answersSoFar,
+ * });
+ *
+ * await client.intakeSubmissions().update({
+ *   session,
+ *   event: Event.IntakeCompleted,
+ *   teleformId,
+ *   data: allAnswers,
+ * });
+ * ```
+ *
+ * `data` is cumulative: send every answer collected so far on each call, not just
+ * the fields that changed. Answers that are files rather than values go through
+ * the upload methods on this same resource.
+ */
+declare class IntakeSubmissions extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    view<T = Record<string, unknown>>(options: IntakeViewOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    create<T = Record<string, unknown>>(options: IntakeWriteOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(options: IntakeWriteOptions): Promise<Response$1<T>>;
+    /** Smallest part the multipart endpoint accepts: 5 MB. */
+    static readonly MIN_PART_SIZE: number;
+    /** Largest part the multipart endpoint accepts: 25 MB. */
+    static readonly MAX_PART_SIZE: number;
+    /** Part size {@link IntakeSubmissions.uploadLargeFile} uses by default: 10 MB. */
+    static readonly DEFAULT_PART_SIZE: number;
+    /**
+     * 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.
+     */
+    uploadFile<T = Record<string, unknown>>(options: UploadFileOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    initiateMultipartUpload<T = Record<string, unknown>>(options: InitiateMultipartOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    uploadMultipartPart<T = Record<string, unknown>>(options: UploadPartOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    finishMultipartUpload<T = Record<string, unknown>>(options: FinishMultipartOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    abortMultipartUpload<T = Record<string, unknown>>(uploadId: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    uploadLargeFile<T = Record<string, unknown>>(options: UploadLargeFileOptions): Promise<Response$1<T>>;
+}
+
+/**
+ * Lab tests - the diagnostic panels a product may require.
+ *
+ * Some treatments cannot be prescribed without a result: a blood panel, a
+ * hormone level. A lab test is the server-side definition of one such
+ * requirement, and products reference the tests they depend on. A storefront reads
+ * this to tell a buyer, before they pay, that a test will be part of their
+ * treatment.
+ *
+ * Read-only, and configured in your AsterMD dashboard.
+ */
+declare class LabTests extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Medications - the reference list of drugs the platform knows about.
+ *
+ * This is a lookup table, not a catalogue of things to sell: it is what a
+ * storefront renders when an intake form asks "which medications are you
+ * currently taking?" Answers picked from this list arrive at the clinician as
+ * recognised drugs rather than free text, which is the difference between a
+ * reviewable history and a paragraph someone has to interpret.
+ *
+ * List-only by design - the API exposes no single-medication endpoint, so
+ * neither does the SDK. Filter through the query parameters to implement a
+ * type-ahead rather than downloading the whole list.
+ */
+declare class Medications extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+}
+
+/**
+ * Opportunities - a prospect who has identified themselves and is worth
+ * following up.
+ *
+ * This is the commercial record of the order flow, and the point where an
+ * anonymous session becomes a named person. Create it once you have a name and a
+ * contact address, typically right after the pre-qualifying form, and attach the
+ * sessions that led to it so the whole journey stays connected:
+ *
+ * ```ts
+ * const opportunity = await client.opportunities().create({
+ *   first_name: 'Jane',
+ *   email: 'jane@example.test',
+ *   sessions: [session],
+ * });
+ * ```
+ *
+ * Attaching sessions is what makes attribution work: without them the server has
+ * a lead with no idea where it came from. An opportunity can carry several
+ * sessions, which is what you want when a prospect returns across devices or
+ * days.
+ *
+ * Where this record is commercial, {@link Patients} is its clinical counterpart -
+ * created later, once the prospect is actually proceeding with treatment.
+ */
+declare class Opportunities extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(data: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(id: string, data: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    status<T = Record<string, unknown>>(id: string, status: string): Promise<Response$1<T>>;
+}
+
+/** Options for {@link Patients.submitHealthInformation}. */
+interface SubmitHealthInformationOptions {
+    /**
+     * The health information to record. Forwarded unmodified; see the API
+     * reference in your AsterMD dashboard for the accepted fields.
+     */
+    data: Record<string, unknown>;
+    /**
+     * Verification token proving the patient authorised this submission, sent as
+     * the `x-phi-verification-token` header. Required by the server for
+     * submissions that need explicit patient confirmation.
+     */
+    phiVerificationToken?: string;
+}
+/**
+ * Patients - the person receiving care, and the most sensitive data in the SDK.
+ *
+ * A patient record is created once the prospect has qualified and is proceeding
+ * with treatment, and it is what a clinician's review, a prescription, and an
+ * order all hang from. Where an {@link Opportunities} record is a commercial
+ * artifact, this is a clinical one.
+ *
+ * Everything on this resource carries personal and protected health information.
+ * Two consequences worth knowing about:
+ *
+ * The SDK never writes a request or response body from any `patients/*` endpoint
+ * to a debug log, even with `debugRedact: false` - those bodies are dropped
+ * wholesale rather than masked. Debug entries for these calls show the method,
+ * URL, and status only.
+ *
+ * Health-information submission is a two-step flow when the server requires
+ * explicit patient confirmation: {@link Patients.verifyHealthInformationOtp}
+ * confirms a one-time code the patient received, and the resulting token is
+ * passed to {@link Patients.submitHealthInformation} as
+ * `phiVerificationToken`.
+ *
+ * Handling this data does not by itself make your application HIPAA compliant -
+ * that depends on your own infrastructure, policies, and agreements. Contact
+ * info@astermd.com regarding a Business Associate Agreement.
+ */
+declare class Patients extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(data: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(id: string, data: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    status<T = Record<string, unknown>>(id: string, status: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    submitHealthInformation<T = Record<string, unknown>>(options: SubmitHealthInformationOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    verifyHealthInformationOtp<T = Record<string, unknown>>(data: Record<string, unknown>): Promise<Response$1<T>>;
+}
+
+/**
+ * Products - the read-only catalogue your storefront sells from.
+ *
+ * A product carries everything a storefront needs to render it: names,
+ * descriptions, images, variants, prices, purchase quantity limits, and the
+ * questionnaire a buyer must complete. All of it is configured in your AsterMD
+ * dashboard, and the SDK only reads it - a storefront never creates or edits a
+ * product.
+ *
+ * Which products a given selling surface may offer is a channel decision, so
+ * {@link Channels.assignedProducts} and {@link Channels.details} are usually the
+ * better starting point for a catalogue page. Reach for this resource when you
+ * need the full product list regardless of channel, or one product by id.
+ *
+ * Image and asset paths come back relative. Resolve them with
+ * `client.config().assetUrl(path)`, and treat the result as a fetch URL: download
+ * the asset once and serve your own copy rather than hot-linking.
+ */
+declare class Products extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/** Options for {@link Sessions.create}. */
+interface SessionCreateOptions {
+    /**
+     * Attribution and context to record against the session - UTM parameters,
+     * referrer, landing page. Forwarded unmodified; see the API reference in your
+     * AsterMD dashboard for the recognised keys.
+     */
+    data?: Record<string, unknown>;
+    /** The visitor's user agent, forwarded as the `User-Agent` header. */
+    userAgent?: string;
+    /** The visitor's IP address, forwarded as the `X-Original-Client-Ip` header. */
+    clientIp?: string;
+}
+/** Options for {@link Sessions.view}. */
+interface SessionViewOptions {
+    /** Session identifiers to fetch. Sent as a comma-separated `session_ids` query. */
+    sessions: string[];
+    /** IANA time zone used to render timestamps in the response. */
+    tz?: string;
+}
+/**
+ * Sessions - the thread that ties one visitor's whole journey together.
+ *
+ * A session is the first thing an order flow creates and the value every later
+ * call is attached to: intake submissions, the cart, checkout events, and finally
+ * the opportunity. Creating one also records an implicit `visit_page` event
+ * server-side, so the funnel starts measuring from that moment.
+ *
+ * Create the session as early as the visitor's first page view, keep the returned
+ * identifier for the length of their visit - in a cookie or your own server-side
+ * session - and pass it to every subsequent call:
+ *
+ * ```ts
+ * const { session } = (
+ *   await client.sessions().create<{ session: string }>({
+ *     userAgent: request.headers['user-agent'],
+ *     clientIp: request.ip,
+ *   })
+ * ).data();
+ * ```
+ *
+ * Passing the visitor's user agent and IP matters: the server uses them for
+ * attribution and geographic checks, and without them every session appears to
+ * originate from your server rather than from the visitor.
+ */
+declare class Sessions extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(options?: SessionCreateOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(options: SessionViewOptions): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    update<T = Record<string, unknown>>(session: string, data?: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    delete<T = Record<string, unknown>>(session: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Shipping options - the delivery methods available for an order.
+ *
+ * Each option carries its name, price, and expected delivery window, which is
+ * what a checkout page needs to let a buyer choose. Which options apply can depend
+ * on the products in the cart and on the destination, so fetch them at checkout
+ * rather than hardcoding a list.
+ *
+ * Read-only, and configured in your AsterMD dashboard.
+ */
+declare class Shippings extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/**
+ * Teleforms - the questionnaire definitions your storefront renders.
+ *
+ * A teleform is the server-side definition of a form: its fields, their types,
+ * their order, and the validation the clinician's workflow expects. Both the
+ * pre-qualifying questionnaire and the full intake questionnaire are teleforms.
+ * Fetch the definition, render it in your own UI, and submit the answers through
+ * {@link IntakeSubmissions} together with the teleform's id.
+ *
+ * There are two ways in. {@link Teleforms.viewByIdentifier} takes the stable
+ * human-readable identifier you configured in your AsterMD dashboard, which is
+ * what a storefront normally has hardcoded or in configuration.
+ * {@link Teleforms.view} takes the generated id, which is what appears in API
+ * responses elsewhere.
+ *
+ * Definitions change when someone edits the form in the dashboard, so fetch them
+ * rather than embedding a copy - but they change rarely, so caching the result
+ * for minutes rather than seconds is reasonable.
+ */
+declare class Teleforms extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    viewByIdentifier<T = Record<string, unknown>>(identifier: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+}
+
+/** Options for {@link Treatments.sync}. */
+interface TreatmentSyncOptions {
+    /** The session the orders belong to. */
+    session: string;
+    /** Order identifiers from your own commerce system. */
+    orderIds: string[];
+    /** Campaign attribution to record alongside the orders. */
+    utmSource?: string;
+    /** The visitor's user agent, forwarded as the `User-Agent` header. */
+    userAgent?: string;
+}
+/**
+ * Treatments - the order, once money has actually changed hands.
+ *
+ * A treatment is the end of the order flow and the start of the clinical one:
+ * the record a clinician reviews, prescribes against, and that fulfilment works
+ * from. Create it *after* your own payment flow has settled, never before - the
+ * SDK does not process payments, and a treatment recorded against an unsettled
+ * payment puts an order into the clinical queue that may never be paid for.
+ *
+ * There are two ways to record one. {@link Treatments.create} takes the order
+ * explicitly, which is what you want when your storefront owns checkout.
+ * {@link Treatments.sync} takes a session and a list of order identifiers from
+ * your own commerce system, which is what you want when checkout happened
+ * elsewhere and you are reconciling after the fact.
+ *
+ * ```ts
+ * await client.treatments().create({
+ *   external_order_id: 'EXT-123',
+ *   patient: { id: patientId },
+ *   product: { id: productId },
+ * });
+ * ```
+ */
+declare class Treatments extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    create<T = Record<string, unknown>>(data: Record<string, unknown>): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    view<T = Record<string, unknown>>(id: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    list<T = Record<string, unknown>>(query?: QueryParams): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    sync<T = Record<string, unknown>>(options: TreatmentSyncOptions): Promise<Response$1<T>>;
+}
+
+/**
+ * The kind of identity check to run through {@link Verification.verifyIdentity}.
+ *
+ * Each value selects a different check at the configured provider, and each
+ * expects a different payload alongside it - a cross-check of supplied details,
+ * a date-of-birth confirmation, or a Social Security Number confirmation. The
+ * required fields per check are in the API reference in your AsterMD dashboard.
+ *
+ * These calls carry PII, and `SsnVerify` in particular. The SDK never writes
+ * their request bodies to a debug log.
+ */
+declare const IdentityCheck: Readonly<{
+    /** Cross-check the supplied identity details against the provider's records. */
+    readonly Crosscheck: "crosscheck";
+    /** Confirm the supplied date of birth. */
+    readonly DobVerify: "dob_verify";
+    /** Confirm the supplied Social Security Number. */
+    readonly SsnVerify: "ssn_verify";
+}>;
+/** Any identity-check wire value. A bare string literal satisfies this type. */
+type IdentityCheck = (typeof IdentityCheck)[keyof typeof IdentityCheck];
+
+/**
+ * Verification - checking that the details a prospect typed are real.
+ *
+ * Telehealth needs more confidence in an address, an email, and an identity than
+ * ordinary commerce does: a prescription goes to a physical person at a physical
+ * place. These endpoints proxy the provider configured for your organisation, and
+ * normalise its answers, so your storefront gets one shape regardless of which
+ * provider sits behind it.
+ *
+ * Address autofill and verification belong at the point of entry - autofill as
+ * the buyer types, verification before checkout completes. Email verification
+ * catches typos and disposable addresses before they cost you a lost patient.
+ * Identity verification is the strongest check and is usually required before a
+ * clinician will review a case; which variant applies is carried by
+ * {@link IdentityCheck}.
+ *
+ * Note where these calls appear in debug logs. Redaction covers headers and
+ * bodies but never the URL, and the address and email endpoints take their input
+ * as a query parameter - so a debug entry for those calls contains the address or
+ * email that was checked. That is worth knowing when deciding where debug logs
+ * are written and how long they are kept. Identity verification is the exception:
+ * it is a POST, and its body is dropped from logs entirely because it carries
+ * PII.
+ */
+declare class Verification extends AbstractResource {
+    /**
+     * @param transport The shared transport.
+     */
+    constructor(transport: 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.
+     */
+    autofillAddress<T = Record<string, unknown>>(search: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    verifyAddress<T = Record<string, unknown>>(address: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    verifyEmail<T = Record<string, unknown>>(email: string): Promise<Response$1<T>>;
+    /**
+     * 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.
+     */
+    verifyIdentity<T = Record<string, unknown>>(check: IdentityCheck, data: Record<string, unknown>): Promise<Response$1<T>>;
+}
+
+/** Options accepted by {@link AsterMDClient}. */
+interface AsterMDClientOptions {
+    /** OAuth2 client ID issued from your AsterMD dashboard. */
+    clientId: string;
+    /**
+     * OAuth2 client secret. Load it from an environment variable or a secrets
+     * manager - never commit it and never ship it to a browser.
+     */
+    clientSecret: string;
+    /** Bare API hostname, no scheme and no path. Defaults to `api.astermd.com`. */
+    baseHost?: string;
+    /** Client used for every request. Defaults to {@link FetchHttpClient}. */
+    httpClient?: HttpClient;
+    /** Where the bearer token is cached. Defaults to {@link InMemoryTokenStore}. */
+    tokenStore?: TokenStore;
+    /** Per-request timeout in seconds. Must be >= 1. Defaults to 10. */
+    timeoutSeconds?: number;
+    /**
+     * Turn on debug logging of every request and response. Requires `debugFile` or
+     * `debugSink`. Defaults to `false`.
+     */
+    debug?: boolean;
+    /**
+     * Base path for daily log files, e.g. `/var/log/astermd/sdk.log`. Dated
+     * filenames are derived from it. Ignored when `debugSink` is given.
+     */
+    debugFile?: string;
+    /**
+     * Receives each formatted entry instead of a file. Supplying this makes
+     * retention and delivery yours.
+     */
+    debugSink?: DebugSink;
+    /** IANA time zone for log timestamps and daily filenames. Defaults to `UTC`. */
+    debugTimezone?: string;
+    /**
+     * Mask credentials and PHI in debug output. Defaults to `true`. Setting it
+     * `false` writes live bearer tokens and the client secret to your sink - never
+     * do that in production.
+     */
+    debugRedact?: boolean;
+    /** Days of log files to keep; `0` keeps everything. Defaults to 7. */
+    debugRetentionDays?: number;
+}
+/**
+ * The SDK's entry point: one client, seventeen resources.
+ *
+ * Construct it once at application start and share it. It holds the credentials,
+ * caches the bearer token, and owns the single transport every resource dispatches
+ * through, so creating one per request would throw away the token cache and cost a
+ * credential exchange each time.
+ *
+ * ```ts
+ * import { AsterMDClient, Event } from '@astermd-hq/sdk';
+ *
+ * const client = new AsterMDClient({
+ *   clientId: process.env.ASTERMD_CLIENT_ID!,
+ *   clientSecret: process.env.ASTERMD_CLIENT_SECRET!,
+ * });
+ *
+ * const { session } = (
+ *   await client.sessions().create<{ session: string }>()
+ * ).data();
+ *
+ * await client.intakeSubmissions().create({
+ *   session,
+ *   event: Event.PreQualifyingInitiated,
+ *   teleformId: 'your-teleform-id',
+ *   data: answers,
+ * });
+ * ```
+ *
+ * Credentials are issued from your AsterMD dashboard, which is also where the
+ * full API reference lives. This client holds a secret, so it belongs on a
+ * server: never construct it in code that reaches a browser.
+ *
+ * Authentication needs no attention from you. The token is acquired lazily on the
+ * first call, reused until it is close to expiring, refreshed automatically if the
+ * server rejects it, and the organisation it authorises is encoded inside it -
+ * which is why no method here takes an organisation argument.
+ *
+ * Every accessor is memoized, so `client.sessions()` returns the same instance
+ * each time and calling it in a hot path costs nothing.
+ */
+declare class AsterMDClient {
+    #private;
+    /**
+     * @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: AsterMDClientOptions);
+    /**
+     * Returns the immutable configuration this client was built with.
+     *
+     * @returns The configuration, including {@link Config.assetUrl}.
+     */
+    config(): 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: string): string;
+    /** Sessions - the thread tying one visitor's journey together. */
+    sessions(): Sessions;
+    /** Intake submissions - pre-qualifying and intake questionnaire answers. */
+    intakeSubmissions(): IntakeSubmissions;
+    /** Carts - what the visitor intends to buy. */
+    carts(): Carts;
+    /** Checkout events - progress through the checkout funnel. */
+    checkoutEvents(): CheckoutEvents;
+    /** Teleforms - the questionnaire definitions your storefront renders. */
+    teleforms(): Teleforms;
+    /** Patients - the person receiving care. Carries PHI. */
+    patients(): Patients;
+    /** Opportunities - a named prospect worth following up. */
+    opportunities(): Opportunities;
+    /** Treatments - the order, once payment has settled. */
+    treatments(): Treatments;
+    /** Doctors' networks - handing a case to the clinicians who review it. */
+    doctorsNetworks(): DoctorsNetworks;
+    /** Channels - the storefront's own server-side configuration. */
+    channels(): Channels;
+    /** Products - the read-only catalogue. */
+    products(): Products;
+    /** Categories - how the catalogue is grouped for browsing. */
+    categories(): Categories;
+    /** Lab tests - diagnostic panels a product may require. */
+    labTests(): LabTests;
+    /** Medications - the reference list backing "what are you currently taking?". */
+    medications(): Medications;
+    /** Shipping options - delivery methods available for an order. */
+    shippings(): Shippings;
+    /** Verification - address, email, and identity checks. */
+    verification(): Verification;
+    /** Geo - where a visitor is, and whether you may serve them. */
+    geo(): Geo;
+}
+
+/**
+ * Base class for every error the SDK raises.
+ *
+ * Catching `AsterMDError` catches everything this SDK can throw and nothing it
+ * cannot, which makes it the right thing to guard an integration boundary with.
+ * Two branches descend from it: {@link TransportError} for failures where no HTTP
+ * response was ever received, and {@link ApiError} for everything the server
+ * answered with a non-2xx status.
+ *
+ * The class is abstract - the SDK never throws it directly.
+ */
+declare abstract class AsterMDError extends Error {
+    protected constructor(message: string, options?: ErrorOptions);
+}
+
+/**
+ * The API answered with a non-2xx status.
+ *
+ * This is the base for every status-carrying error and the class the SDK throws
+ * for any status it does not map to something more specific - a 400, a 500, a
+ * 502 from an upstream hiccup. The decoded response envelope is kept intact on
+ * {@link ApiError.envelope} so an integrator can inspect whatever the server
+ * chose to send alongside the status.
+ *
+ * Four subclasses cover the statuses worth branching on explicitly:
+ * {@link AuthenticationError} (401), {@link NotFoundError} (404),
+ * {@link ValidationError} (422), and {@link RateLimitError} (429).
+ */
+declare class ApiError extends AsterMDError {
+    #private;
+    /**
+     * @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: string, statusCode: number, envelope: Record<string, unknown>);
+    /**
+     * Returns the HTTP status code that caused this error.
+     *
+     * @returns The status code, e.g. `404` or `500`.
+     */
+    statusCode(): number;
+    /**
+     * 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(): Readonly<Record<string, unknown>>;
+}
+
+/**
+ * The API rejected the credentials or the bearer token (HTTP 401).
+ *
+ * The SDK does not raise this on the first 401. {@link TokenManager} refreshes
+ * the token and the request is replayed once; only a second 401 surfaces here.
+ * So seeing this error means a fresh token was also refused - check the client ID
+ * and secret, and that the credentials are still active in your AsterMD
+ * dashboard.
+ */
+declare class AuthenticationError extends ApiError {
+    constructor(message: string, statusCode: number, envelope: Record<string, unknown>);
+}
+
+/**
+ * The addressed resource does not exist (HTTP 404).
+ *
+ * Raised when an id in the request path matches nothing the calling organisation
+ * can see. Note that the organisation scope lives inside the JWT, so an id
+ * belonging to another organisation is indistinguishable from one that never
+ * existed - both arrive here.
+ */
+declare class NotFoundError extends ApiError {
+    constructor(message: string, statusCode: number, envelope: Record<string, unknown>);
+}
+
+/**
+ * The calling organisation exceeded its request allowance (HTTP 429).
+ *
+ * When the server sent a `Retry-After` header, its value in seconds is available
+ * on {@link RateLimitError.retryAfter} - wait at least that long before trying
+ * again. The header is optional, so treat `null` as "back off on your own
+ * schedule" rather than "retry immediately".
+ */
+declare class RateLimitError extends ApiError {
+    #private;
+    /**
+     * @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: string, statusCode: number, envelope: Record<string, unknown>, retryAfter: number | null);
+    /**
+     * Returns the server-advised wait in seconds before retrying.
+     *
+     * @returns Seconds to wait, or `null` when the server did not say.
+     */
+    retryAfter(): number | null;
+}
+
+/**
+ * A request never reached the API, or its response never came back.
+ *
+ * Raised for DNS failures, TLS errors, connection resets, and timeouts - every
+ * case where the SDK has no HTTP status to reason about. The originating error is
+ * preserved on `cause`. There is no `statusCode()` here by design: nothing was
+ * returned to have a status.
+ *
+ * These are usually worth retrying with backoff; an {@link ApiError} usually is
+ * not.
+ */
+declare class TransportError extends AsterMDError {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/**
+ * The request was well-formed but the server refused its contents (HTTP 422).
+ *
+ * The interesting part is {@link ValidationError.fieldErrors}, which maps each
+ * rejected field to the messages the server produced for it - exactly the shape
+ * a form needs to render inline errors next to the offending inputs.
+ */
+declare class ValidationError extends ApiError {
+    #private;
+    /**
+     * @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: string, statusCode: number, envelope: Record<string, unknown>, fieldErrors: Record<string, string[]>);
+    /**
+     * Returns the per-field validation messages the server produced.
+     *
+     * @returns Field name → messages. Empty when the server sent no `errors` key.
+     */
+    fieldErrors(): Readonly<Record<string, string[]>>;
+}
+
+/**
+ * The default {@link HttpClient}: the platform `fetch` plus a timeout.
+ *
+ * This is what {@link AsterMDClient} uses unless you inject something else. It
+ * adds exactly two things to `fetch`. First, a deadline: every request carries an
+ * `AbortSignal.timeout()` built from the configured `timeoutSeconds`, covering
+ * connection and response together. Second, uniform failures: a DNS error, a
+ * connection reset, a TLS failure, or a timeout all surface as
+ * {@link TransportError} with the original error preserved on `cause`, so
+ * integrators can catch one type instead of guessing at platform error shapes.
+ *
+ * It holds no connection state, so one instance is safely shared across
+ * concurrent requests.
+ */
+declare class FetchHttpClient implements HttpClient {
+    #private;
+    /**
+     * @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?: number, fetchImpl?: typeof fetch);
+    /**
+     * 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.
+     */
+    sendRequest(request: Request): Promise<Response>;
+}
+
+/**
+ * The default {@link TokenStore}: keeps the token in memory for the life of the
+ * process.
+ *
+ * Right for a long-running server - an Express or Fastify app, a worker - where
+ * one credential exchange serves every request until the token expires. Nothing
+ * is written anywhere, so nothing can leak to disk.
+ *
+ * Wrong where each request runs in a fresh process or isolate, since the cache
+ * dies with it and every request pays for its own token exchange. Use
+ * {@link FileTokenStore} or your own {@link TokenStore} there.
+ */
+declare class InMemoryTokenStore implements TokenStore {
+    #private;
+    /**
+     * Returns the token held in memory, or `null` before the first exchange.
+     *
+     * @returns The cached token, or `null`.
+     */
+    get(): Promise<Token | null>;
+    /**
+     * Replaces the token held in memory.
+     *
+     * @param token The token to cache.
+     */
+    put(token: Token): Promise<void>;
+    /**
+     * Drops the token held in memory.
+     */
+    clear(): Promise<void>;
+}
+
+/**
+ * File-backed {@link TokenStore} that persists the JWT across processes.
+ *
+ * Unlike {@link InMemoryTokenStore}, this writes the token as JSON to disk so it
+ * survives a process boundary. That makes it the right choice where each request
+ * or invocation gets a fresh process and an in-memory cache would never be hit,
+ * as long as those processes share a filesystem.
+ *
+ * ```ts
+ * const client = new AsterMDClient({
+ *   clientId: process.env.ASTERMD_CLIENT_ID!,
+ *   clientSecret: process.env.ASTERMD_CLIENT_SECRET!,
+ *   tokenStore: new FileTokenStore('/var/cache/astermd/token.json'),
+ * });
+ * ```
+ *
+ * The parent directory is created if absent. The file is written `0o600` - owner
+ * read and write only - so the token is not world-readable on a shared host. It
+ * must be writable by the service account and should sit outside any document
+ * root. One file per set of API credentials is enough.
+ *
+ * Writes are atomic: the content goes to a uniquely named temporary file in the
+ * same directory and is then renamed over the target, so a concurrent reader
+ * sees either the whole previous token or the whole new one. Both reads and
+ * writes treat any failure - missing file, bad permissions, a read-only cache
+ * directory, truncated or corrupt JSON - as "no token" rather than raising,
+ * which makes a damaged cache cost one extra credential exchange instead of
+ * breaking the request it was only meant to optimise.
+ */
+declare class FileTokenStore implements TokenStore {
+    #private;
+    /**
+     * @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: string);
+    /**
+     * 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.
+     */
+    get(): Promise<Token | null>;
+    /**
+     * 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.
+     */
+    put(token: Token): Promise<void>;
+    /**
+     * 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.
+     */
+    clear(): Promise<void>;
+}
+
+/** Options accepted by {@link DailyFileLogSink}. */
+interface DailyFileLogSinkOptions {
+    /**
+     * Undated path the daily filenames are derived from, e.g.
+     * `/var/log/astermd/sdk.log`. A path with no extension gets `.log`.
+     */
+    basePath: string;
+    /**
+     * Days of logs to keep. A file is removed once its date is more than this many
+     * days before today. Use `0` to keep every file forever. Defaults to 7.
+     */
+    retentionDays?: number;
+    /**
+     * IANA time zone deciding which calendar day an entry belongs to. Pass the same
+     * zone used for log timestamps so filenames and their contents agree. Defaults
+     * to `UTC`.
+     */
+    timeZone?: string;
+}
+/**
+ * Debug-log sink that writes one file per calendar day and prunes old files.
+ *
+ * The debug logger emits one entry per HTTP request. Appending those to a single
+ * file grows without bound, which is why this sink dates each file and deletes
+ * the ones that have aged out - the same arrangement as conventional daily log
+ * rotation, but self-contained, so no external rotation tooling is needed.
+ *
+ * You give it a *base path* and it derives dated filenames from it, keeping the
+ * directory, stem, and extension you chose:
+ *
+ * ```
+ * basePath: /var/log/astermd/sdk.log
+ *
+ * /var/log/astermd/sdk-2026-09-08.log   ← today, appended to
+ * /var/log/astermd/sdk-2026-09-07.log
+ * /var/log/astermd/sdk-2026-09-01.log   ← deleted once it is over 7 days old
+ * ```
+ *
+ * {@link AsterMDClient} builds one for you when you pass `debugFile`; construct
+ * it directly only if you want to reuse one sink across several clients.
+ *
+ * Pruning reads the date out of each filename rather than the filesystem's
+ * modification time, so a file that was merely touched is still removed on
+ * schedule and unrelated files sharing the directory are never matched. It runs
+ * at most once per instance, on the first write, which keeps it off the hot path.
+ *
+ * Writes are serialized through an internal promise chain, so concurrent requests
+ * cannot interleave halves of two entries. Every I/O failure is swallowed: losing
+ * a debug entry is never worth failing the request that produced it.
+ *
+ * Supplying your own `debugSink` bypasses this class entirely, and retention then
+ * becomes that system's responsibility.
+ */
+declare class DailyFileLogSink {
+    #private;
+    /**
+     * @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: DailyFileLogSinkOptions);
+    /**
+     * 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.
+     */
+    write(entry: string): Promise<void>;
+    /**
+     * 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(): string;
+}
+
+/** One integration's mapping for a variant or a single-price product. */
+interface ChannelProductMapping {
+    /** The integration's type, from the mapping's `integration.type`. */
+    type: unknown;
+    /** Every other key of the raw `mapping` object, verbatim. */
+    [key: string]: unknown;
+}
+/** A purchasable variant of a product, with its price and integration mapping. */
+interface ChannelProductVariant {
+    id: unknown;
+    name: unknown;
+    sku: unknown;
+    price: unknown;
+    intro_price: unknown;
+    sale_price: unknown;
+    sale_start: unknown;
+    sale_end: unknown;
+    mapping: ChannelProductMapping | null;
+}
+/** Single-purchase pricing for a product that has no variants. */
+interface ChannelProductSingle {
+    price: unknown;
+    intro_price: unknown;
+    sale_price: unknown;
+    sale_start: unknown;
+    sale_end: unknown;
+    mapping: ChannelProductMapping | null;
+}
+/** A product as the channel offers it. */
+interface ChannelProduct {
+    id: unknown;
+    name: unknown;
+    type: unknown;
+    sku: unknown;
+    status: unknown;
+    visibility: unknown;
+    image: unknown;
+    description_long: unknown;
+    description_short: unknown;
+    restrict_multiple: unknown;
+    min_buy_qty: unknown;
+    max_buy_qty: unknown;
+    stock: unknown;
+    categories: unknown[];
+    condition_treated: unknown[];
+    teleforms: unknown;
+    labtest: unknown[];
+    add_ons: ChannelProduct[];
+    single: ChannelProductSingle | null;
+    variants: ChannelProductVariant[];
+}
+/** The channel's payment processor configuration. */
+interface ChannelPaymentProcessor {
+    id: unknown;
+    name: unknown;
+    provider: unknown;
+    type: unknown;
+    config: unknown;
+}
+/** The flattened channel-detail envelope. */
+interface ChannelDetailView {
+    id: unknown;
+    name: unknown;
+    description: unknown;
+    status: unknown;
+    type: unknown;
+    auto_inc_id: unknown;
+    payment_processor: ChannelPaymentProcessor | null;
+    products: ChannelProduct[];
+}
+/**
+ * Read model over the channel-detail envelope.
+ *
+ * {@link Channels.details} returns everything a storefront needs in one
+ * response, which makes it efficient and awkward in equal measure: the payload is
+ * deeply nested, uses the server's own field names, and scatters each variant's
+ * integration mapping into a separate parallel list keyed by variant id. Rendering
+ * straight from it means writing that reassembly into your view layer.
+ *
+ * This presenter does the reassembly once. It renames `_id` to `id` throughout,
+ * joins each variant to its mapping, hoists single-purchase pricing out of its
+ * one-element list, flattens reference objects, and recurses through add-ons so
+ * they look like ordinary products:
+ *
+ * ```ts
+ * const detail = ChannelDetail.from((await client.channels().details(channelId)).data());
+ *
+ * for (const product of detail.products) {
+ *   for (const variant of product.variants) {
+ *     render(product.name, variant.name, variant.price, variant.mapping);
+ *   }
+ * }
+ * ```
+ *
+ * Field names in the output stay snake_case, matching the PHP SDK's presenter, so
+ * a value produced by one can be compared against the other. Anything the server
+ * omitted comes back as `null` rather than `undefined`, and an omitted list comes
+ * back empty - so a view can read straight through without optional chaining at
+ * every level.
+ *
+ * The class is not instantiable; it exposes only {@link ChannelDetail.from}.
+ */
+declare class ChannelDetail {
+    private 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: Record<string, unknown>): ChannelDetailView;
+}
+
+/**
+ * Encrypts and decrypts URL query-parameter tokens using AES-128-CBC, with a
+ * random 16-byte IV prepended to the ciphertext and the whole thing
+ * base64url-encoded.
+ *
+ * Tracking parameters are encrypted so a browser extension cannot read them in
+ * transit. The codec is parameter-agnostic: it carries no knowledge of what it
+ * is transporting.
+ *
+ * Decryption is deliberately total. A malformed, truncated, tampered, or
+ * wrongly-keyed token yields an empty object rather than raising, so a storefront
+ * can fall back to plain parameters instead of failing a page load:
+ *
+ * ```ts
+ * const params = QueryParamCipher.decrypt(
+ *   request.query._amd ?? '',
+ *   process.env.ASTERMD_PARAM_KEY!,
+ * );
+ * // => { aff_id: '123', utm_source: 'news' }   (or {} on any failure)
+ * ```
+ *
+ * The AES key is **never** stored in this SDK. Supply it at every call site from
+ * your own configuration - an environment variable, a secrets manager - and keep
+ * it in step with whichever service mints the tokens. Contact info@astermd.com to
+ * obtain or rotate the key for your organisation.
+ *
+ * **On integrity:** AES-CBC provides confidentiality but not authentication, so a
+ * token cannot be proven unmodified. Treat decrypted parameters as untrusted
+ * input and validate them before use.
+ *
+ * **On the wire format and the PHP SDK:** the encrypted payload is a JSON *list*
+ * of `{ key, value }` objects, which is what the PHP SDK writes and reads, so a
+ * token minted by either SDK is readable by the other. This class's own surface
+ * differs from the PHP one, though: it takes and returns a plain object, since
+ * that is what a JS caller wants, and converts at the boundary. A duplicate key
+ * on the wire resolves to its last occurrence.
+ */
+declare class QueryParamCipher {
+    private 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: string, keyHex: string): Record<string, string>;
+    /**
+     * 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: Record<string, string>, keyHex: string): string;
+}
+
+export { AbstractResource, ApiError, AsterMDClient, type AsterMDClientOptions, AsterMDError, AuthenticationError, type CartWriteOptions, Carts, Categories, ChannelDetail, type ChannelDetailView, type ChannelPaymentProcessor, type ChannelProduct, type ChannelProductMapping, type ChannelProductSingle, type ChannelProductVariant, Channels, CheckoutEvent, type CheckoutEventUpdateOptions, CheckoutEvents, Config, type ConfigOptions, DailyFileLogSink, type DailyFileLogSinkOptions, type DebugSink, DoctorsNetworks, Event, FetchHttpClient, FileTokenStore, FileUpload, type FileUploadFromContentsOptions, type FileUploadFromPathOptions, type FinishMultipartOptions, Geo, type HttpClient, IdentityCheck, InMemoryTokenStore, type InitiateMultipartOptions, IntakeSubmissions, type IntakeViewOptions, type IntakeWriteOptions, LabTests, Medications, type MultipartPart, NotFoundError, Opportunities, Patients, Products, QueryParamCipher, RateLimitError, Response$1 as Response, type ResponseOptions, type SessionCreateOptions, type SessionViewOptions, Sessions, Shippings, type SubmitHealthInformationOptions, Teleforms, Token, type TokenStore, TransportError, type TreatmentSyncOptions, Treatments, type UploadFileOptions, type UploadLargeFileOptions, type UploadPartOptions, ValidationError, Verification };