@cloudraker/milliseconds 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,330 @@
+//#region src/types.d.ts
+/**
+ * Every public type of the SDK.
+ *
+ * Wire names never change. A field that crosses the wire keeps its exact name from
+ * `decide.schema.ts`, `snake_case` included. Only SDK-invented names are camelCase.
+ */
+interface ClientOptions {
+  /** Your key. Falls back to MS_API_KEY in the environment. */
+  apiKey?: string;
+  /** Default 'https://api.milliseconds.ai'. A trailing slash is trimmed. */
+  baseUrl?: string;
+  /** Per attempt, in milliseconds. Default 60_000. */
+  timeout?: number;
+  /** Retries after the first attempt. Default 2. */
+  maxRetries?: number;
+  /** Merged into every request. It cannot override `authorization`. */
+  headers?: Record<string, string>;
+  /** For tests, proxies, or a Workers service binding. Default globalThis.fetch. */
+  fetch?: typeof globalThis.fetch;
+  /** The key is a secret. Set true only when the bundle never reaches a user. */
+  dangerouslyAllowBrowser?: boolean;
+}
+interface CallOptions {
+  timeout?: number;
+  maxRetries?: number;
+  signal?: AbortSignal;
+  headers?: Record<string, string>;
+}
+/** A Promise of the result. `withUsage()` reaches the headers. */
+type Decision<T> = Promise<T> & {
+  withUsage(): Promise<{
+    result: T;
+    usage: Usage;
+    response: Response;
+  }>;
+};
+interface Usage {
+  /** x-input-chars */
+  inputChars: number;
+  /** x-input-tokens — what this call bills. */
+  inputTokens: number;
+  /** x-inference-ms — model time, summed over the calls this request made. */
+  inferenceMs: number;
+  /** Null when the response carried no x-ratelimit-* headers. */
+  rateLimit: RateLimit | null;
+  /** Every response header. Read a new x-* value with no SDK release. */
+  headers: Headers;
+}
+/**
+ * The numbers come from the previous request at that Cloudflare colo. The middleware
+ * accounts after the response. Read them as a trailing gauge, never as admission control.
+ */
+interface RateLimit {
+  limitRequests: number;
+  remainingRequests: number;
+  /** OpenAI style, for example '5m0s'. */
+  resetRequests: string;
+  limitTokens: number;
+  remainingTokens: number;
+  resetTokens: string;
+}
+type ErrorCode = 'invalid_request' | 'invalid_schema' | 'missing_api_key' | 'invalid_api_key' | 'rate_limit_exceeded' | 'insufficient_quota' | 'runner_error' | 'overloaded' | 'http_error' | 'internal_error' | 'connection_error' | 'timeout' | 'client_error' | (string & {});
+type Input = string | readonly string[];
+/** One text gives one result. A tuple of texts gives a tuple of results, same length. */
+type Fan<T extends Input, R> = T extends readonly string[] ? { -readonly [K in keyof T]: R; } : R;
+/** Label names, or name -> description. */
+type Labels = readonly string[] | Readonly<Record<string, string>>;
+type LabelOf<L extends Labels> = L extends readonly (infer S extends string)[] ? S : Extract<keyof L, string>;
+/** 0 | 1 | ... | n-1 for a tuple. `number` for a plain array. */
+type IndexOf<S extends readonly unknown[]> = number extends S['length'] ? number : Exclude<keyof S, keyof unknown[]> extends (infer K) ? K extends `${infer N extends number}` ? N : never : never;
+interface TreeNode {
+  readonly description?: string;
+  readonly labels?: Tree;
+}
+type Tree = {
+  readonly [label: string]: string | TreeNode;
+};
+/** Every label at every level. What `path` can hold. */
+type TreeLabels<T> = Extract<keyof T, string> | { [K in keyof T]: T[K] extends {
+  labels: infer C extends object;
+} ? TreeLabels<C> : never; }[keyof T];
+/**
+ * Only the labels a walk can stop on. What `label` is.
+ *
+ * An empty `labels` object is a leaf: `decide.service.ts` stops the walk when the child
+ * level holds no key, and `decide.schema.ts` recurses into a non-empty child only.
+ */
+type LeafLabels<T> = Extract<{ [K in keyof T]: T[K] extends {
+  labels: infer C extends object;
+} ? [keyof C] extends [never] ? K : LeafLabels<C> : K; }[keyof T], string>;
+interface YesNoResult<S extends string = string> {
+  statement: S;
+  answer: boolean;
+  probability: number;
+}
+interface ClassifyResult<L extends string = string> {
+  label: L;
+  probability: number;
+  /** 1 = one clear winner. 0 = flat. */
+  confidence: number;
+  scores: Record<L, number>;
+}
+interface ClassifyTreeLevel {
+  label: string;
+  probability: number;
+  confidence: number;
+  /** Only this level's siblings. The keys are narrower than the tree. */
+  scores: Record<string, number>;
+  input_chars: number;
+  input_tokens: number;
+  inference_ms: number;
+}
+interface ClassifyTreeResult<L extends string = string, Leaf extends L = L> {
+  /** The winning label per level, top to bottom. */
+  path: L[];
+  /** The deepest label, the last of `path`. */
+  label: Leaf;
+  /** The product over the levels. */
+  probability: number;
+  confidence: number;
+  /**
+   * One entry per level. The per-level `input_chars` and `input_tokens` do not sum to
+   * `Usage.inputChars`: the header counts one pass over the body, each level re-sends the
+   * text.
+   */
+  levels: ClassifyTreeLevel[];
+}
+interface RateResult<S extends readonly string[] = readonly string[]> {
+  /** The probability-weighted position, 0 to scale.length - 1. Route on this, not `level`. */
+  score: number;
+  level: IndexOf<S>;
+  label: S[number];
+  confidence: number;
+  /** One probability per level, in scale order. */
+  scores: { -readonly [K in keyof S]: number; };
+}
+/** The service sets answer, start and end together, or nulls all three. */
+type AnswerResult<Q extends string = string> = {
+  question: Q;
+  answer: string;
+  probability: number;
+  start: number;
+  end: number;
+} | {
+  question: Q;
+  answer: null;
+  probability: number;
+  start: null;
+  end: null;
+};
+interface Entity<T extends string = string> {
+  type: T;
+  text: string;
+  probability: number;
+  start: number;
+  end: number;
+}
+interface VerifyResult {
+  matches: boolean;
+  probability: number;
+  /** What the text actually says for that field. */
+  found: string[];
+}
+type JsonSchema = {
+  readonly type?: string | readonly string[];
+  readonly [k: string]: unknown;
+};
+/** A Standard Schema object: zod 4, valibot 1.1+, arktype. */
+interface StandardSchemaV1<Output = unknown> {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: {
+      readonly input: unknown;
+      readonly output: Output;
+    };
+  };
+}
+/** A JSON Schema branded with the type it produces. */
+type Typed<T> = JsonSchema & {
+  readonly '~milliseconds.output'?: T;
+};
+type ExtractSchema = JsonSchema | StandardSchemaV1 | Typed<unknown>;
+type SchemaOutput<S> = S extends StandardSchemaV1<infer O> ? O : S extends {
+  '~milliseconds.output'?: infer T;
+} ? [unknown] extends [T] ? FromJsonSchema<S> : T : FromJsonSchema<S>;
+/** Reads a JSON Schema object literal at the type level, exactly as `kindOf` reads it. */
+type FromJsonSchema<S> = S extends {
+  enum: readonly (infer E)[];
+} ? E extends string ? E : string : S extends {
+  type: readonly (infer T extends string)[];
+} ? FromJsonSchema<Omit<S, 'type'> & {
+  type: Exclude<T, 'null'>;
+}> : S extends {
+  type: 'object';
+} ? S extends {
+  properties: infer P;
+} ? { -readonly [K in keyof P]: FromJsonSchema<P[K]>; } : Record<string, never> : S extends {
+  type: 'array';
+} ? S extends {
+  items: infer I;
+} ? I extends {
+  type: 'object';
+} ? object[] : string[] : string[] : S extends {
+  type: 'string';
+} ? string : S extends {
+  type: 'number' | 'integer';
+} ? number : S extends {
+  type: 'boolean';
+} ? boolean : S extends {
+  type: string;
+} ? undefined : string;
+/**
+ * What the runner really sends. A missing value is null. An array of objects is always [].
+ * An array of scalars arrives as strings. An enum is not checked server side. A nested
+ * object is not nullable, because `setPath` materialises it.
+ */
+type Extracted<T> = [T] extends [undefined] ? undefined : [T] extends [readonly unknown[]] ? T extends readonly (infer E)[] ? [E] extends [object] ? never[] : string[] | null : never : [T] extends [object] ? { -readonly [K in keyof T]-?: Extracted<Exclude<T[K], null | undefined>>; } : [T] extends [string] ? string extends T ? string | null : T | (string & {}) | null : T | null;
+//#endregion
+//#region src/client.d.ts
+/** Transport: fetch, retries, errors and usage. Every capability is two lines on top. */
+declare class Client {
+  #private;
+  readonly baseUrl: string;
+  constructor(options?: ClientOptions);
+  /** Escape hatch. Your path, your body, your type, the SDK's auth, retries and errors. */
+  post<R>(path: string, body: unknown, options?: CallOptions): Decision<R>;
+  /** `unwrap` maps the parsed body to the result. It follows the request, never the response. */
+  protected call<R>(path: string, body: unknown, options: CallOptions | undefined, unwrap: (raw: unknown) => R): Decision<R>;
+  private send;
+  private attempt;
+}
+//#endregion
+//#region src/decision-machine.d.ts
+/**
+ * `decision-machine-1` at api.milliseconds.ai. Every capability is a pure function, so
+ * every retry is safe.
+ */
+export declare class DecisionMachine extends Client {
+  /** Paths are `${baseUrl}/v1/${model}/<capability>`. */
+  static readonly model = "decision-machine-1";
+  /**
+   * Answers each statement with yes or no and a probability. The statements share one
+   * inference call, so extra statements are nearly free.
+   */
+  yesNo<const T extends Input, const S extends string | readonly string[]>(input: T, statements: S, options?: CallOptions & {
+    when_true?: string;
+    when_false?: string;
+  }): Decision<Fan<T, S extends readonly string[] ? { -readonly [K in keyof S]: YesNoResult<S[K] & string>; } : YesNoResult<S & string>>>;
+  /** Picks one label and returns the full distribution. Describe each label. */
+  classify<const T extends Input, const L extends Labels>(input: T, labels: L, options?: CallOptions): Decision<Fan<T, ClassifyResult<LabelOf<L>>>>;
+  /**
+   * Runs classify once per level of a nested tree, descending into the winner.
+   *
+   * The per-level `input_chars` and `input_tokens` do not sum to `Usage.inputChars`: the
+   * header counts one pass over the body, and each level re-sends the text.
+   */
+  classifyTree<const T extends Input, const N extends Tree>(input: T, tree: N, options?: CallOptions): Decision<Fan<T, ClassifyTreeResult<TreeLabels<N>, LeafLabels<N>>>>;
+  /** Places the text on an ordered scale of described levels, low to high. */
+  rate<const T extends Input, const S extends readonly string[]>(input: T, scale: S, options?: CallOptions): Decision<Fan<T, RateResult<S>>>;
+  /** Quotes the answer out of the text, with its offsets. `answer` is null when nothing fits. */
+  answer<const T extends Input, const Q extends string | readonly string[]>(input: T, questions: Q, options?: CallOptions): Decision<Fan<T, Q extends readonly string[] ? { -readonly [K in keyof Q]: AnswerResult<Q[K] & string>; } : AnswerResult<Q & string>>>;
+  /**
+   * Fills a JSON Schema from the text. Missing values are null, arrays of objects come back
+   * empty, arrays of scalars come back as strings, and enums are not checked server side.
+   */
+  extract<const T extends Input, const S extends ExtractSchema>(input: T, schema: S, options?: CallOptions): Decision<Fan<T, Extracted<SchemaOutput<S>>>>;
+  /** Finds every span matching each type, with offsets, sorted by start. */
+  entities<const T extends Input, const E extends Labels>(input: T, types: E, options?: CallOptions): Decision<Fan<T, Entity<LabelOf<E>>[]>>;
+  /** Checks whether the text says `value` for `field`. */
+  verify<const T extends Input>(input: T, field: string | {
+    name: string;
+    description?: string;
+  }, value: string | number, options?: CallOptions): Decision<Fan<T, VerifyResult>>;
+  /** `{ results }` is unwrapped for a batch, and the per-text envelope for one text. */
+  private capability;
+}
+//#endregion
+//#region src/errors.d.ts
+/** A brand property, so a duplicated copy of the package in a bundle still matches. */
+declare const BRAND = "~milliseconds.error";
+interface ErrorInit {
+  code: ErrorCode;
+  /** 0 when the call never reached the API. */
+  status?: number;
+  /** The API's own message, unchanged. */
+  apiMessage: string;
+  /** The thrown `message`: the API message plus one hint line. */
+  message?: string;
+  retryAfter?: number | null;
+  rateLimit?: RateLimit | null;
+  response?: Response | null;
+  attempts?: number;
+  retryable?: boolean;
+  cause?: unknown;
+}
+/**
+ * One error class. Switch on `code`: the union narrows exhaustively and never goes stale
+ * when the API adds a code.
+ */
+export declare class MillisecondsError extends Error {
+  readonly name = "MillisecondsError";
+  readonly [BRAND] = true;
+  readonly code: ErrorCode;
+  /** 0 when the call never reached the API. */
+  readonly status: number;
+  /** The API's own message, unchanged. `message` adds one hint line. */
+  readonly apiMessage: string;
+  /** Seconds from the retry-after header. Only 429 rate_limit_exceeded carries it. */
+  readonly retryAfter: number | null;
+  readonly rateLimit: RateLimit | null;
+  readonly response: Response | null;
+  /** Attempts this call made, including the first. */
+  readonly attempts: number;
+  /** True for the codes the SDK retries. */
+  readonly retryable: boolean;
+  constructor(init: ErrorInit);
+}
+export declare function isMillisecondsError(e: unknown): e is MillisecondsError;
+//#endregion
+//#region src/schema.d.ts
+/**
+ * Brands a JSON Schema with the type it produces. One cast, no runtime cost.
+ *
+ * `dm.extract(text, typed<z.infer<typeof S>>(z.toJSONSchema(S)))`
+ */
+export declare const typed: <T>(schema: object) => Typed<T>;
+//#endregion
+export type { AnswerResult, CallOptions, ClassifyResult, ClassifyTreeLevel, ClassifyTreeResult, ClientOptions, Decision, Entity, ErrorCode, ExtractSchema, Extracted, Fan, FromJsonSchema, IndexOf, Input, JsonSchema, LabelOf, Labels, LeafLabels, RateLimit, RateResult, SchemaOutput, StandardSchemaV1, Tree, TreeLabels, TreeNode, Typed, Usage, VerifyResult, YesNoResult };

package/dist/index.d.ts

@@ -0,0 +1,330 @@
+//#region src/types.d.ts
+/**
+ * Every public type of the SDK.
+ *
+ * Wire names never change. A field that crosses the wire keeps its exact name from
+ * `decide.schema.ts`, `snake_case` included. Only SDK-invented names are camelCase.
+ */
+interface ClientOptions {
+  /** Your key. Falls back to MS_API_KEY in the environment. */
+  apiKey?: string;
+  /** Default 'https://api.milliseconds.ai'. A trailing slash is trimmed. */
+  baseUrl?: string;
+  /** Per attempt, in milliseconds. Default 60_000. */
+  timeout?: number;
+  /** Retries after the first attempt. Default 2. */
+  maxRetries?: number;
+  /** Merged into every request. It cannot override `authorization`. */
+  headers?: Record<string, string>;
+  /** For tests, proxies, or a Workers service binding. Default globalThis.fetch. */
+  fetch?: typeof globalThis.fetch;
+  /** The key is a secret. Set true only when the bundle never reaches a user. */
+  dangerouslyAllowBrowser?: boolean;
+}
+interface CallOptions {
+  timeout?: number;
+  maxRetries?: number;
+  signal?: AbortSignal;
+  headers?: Record<string, string>;
+}
+/** A Promise of the result. `withUsage()` reaches the headers. */
+type Decision<T> = Promise<T> & {
+  withUsage(): Promise<{
+    result: T;
+    usage: Usage;
+    response: Response;
+  }>;
+};
+interface Usage {
+  /** x-input-chars */
+  inputChars: number;
+  /** x-input-tokens — what this call bills. */
+  inputTokens: number;
+  /** x-inference-ms — model time, summed over the calls this request made. */
+  inferenceMs: number;
+  /** Null when the response carried no x-ratelimit-* headers. */
+  rateLimit: RateLimit | null;
+  /** Every response header. Read a new x-* value with no SDK release. */
+  headers: Headers;
+}
+/**
+ * The numbers come from the previous request at that Cloudflare colo. The middleware
+ * accounts after the response. Read them as a trailing gauge, never as admission control.
+ */
+interface RateLimit {
+  limitRequests: number;
+  remainingRequests: number;
+  /** OpenAI style, for example '5m0s'. */
+  resetRequests: string;
+  limitTokens: number;
+  remainingTokens: number;
+  resetTokens: string;
+}
+type ErrorCode = 'invalid_request' | 'invalid_schema' | 'missing_api_key' | 'invalid_api_key' | 'rate_limit_exceeded' | 'insufficient_quota' | 'runner_error' | 'overloaded' | 'http_error' | 'internal_error' | 'connection_error' | 'timeout' | 'client_error' | (string & {});
+type Input = string | readonly string[];
+/** One text gives one result. A tuple of texts gives a tuple of results, same length. */
+type Fan<T extends Input, R> = T extends readonly string[] ? { -readonly [K in keyof T]: R; } : R;
+/** Label names, or name -> description. */
+type Labels = readonly string[] | Readonly<Record<string, string>>;
+type LabelOf<L extends Labels> = L extends readonly (infer S extends string)[] ? S : Extract<keyof L, string>;
+/** 0 | 1 | ... | n-1 for a tuple. `number` for a plain array. */
+type IndexOf<S extends readonly unknown[]> = number extends S['length'] ? number : Exclude<keyof S, keyof unknown[]> extends (infer K) ? K extends `${infer N extends number}` ? N : never : never;
+interface TreeNode {
+  readonly description?: string;
+  readonly labels?: Tree;
+}
+type Tree = {
+  readonly [label: string]: string | TreeNode;
+};
+/** Every label at every level. What `path` can hold. */
+type TreeLabels<T> = Extract<keyof T, string> | { [K in keyof T]: T[K] extends {
+  labels: infer C extends object;
+} ? TreeLabels<C> : never; }[keyof T];
+/**
+ * Only the labels a walk can stop on. What `label` is.
+ *
+ * An empty `labels` object is a leaf: `decide.service.ts` stops the walk when the child
+ * level holds no key, and `decide.schema.ts` recurses into a non-empty child only.
+ */
+type LeafLabels<T> = Extract<{ [K in keyof T]: T[K] extends {
+  labels: infer C extends object;
+} ? [keyof C] extends [never] ? K : LeafLabels<C> : K; }[keyof T], string>;
+interface YesNoResult<S extends string = string> {
+  statement: S;
+  answer: boolean;
+  probability: number;
+}
+interface ClassifyResult<L extends string = string> {
+  label: L;
+  probability: number;
+  /** 1 = one clear winner. 0 = flat. */
+  confidence: number;
+  scores: Record<L, number>;
+}
+interface ClassifyTreeLevel {
+  label: string;
+  probability: number;
+  confidence: number;
+  /** Only this level's siblings. The keys are narrower than the tree. */
+  scores: Record<string, number>;
+  input_chars: number;
+  input_tokens: number;
+  inference_ms: number;
+}
+interface ClassifyTreeResult<L extends string = string, Leaf extends L = L> {
+  /** The winning label per level, top to bottom. */
+  path: L[];
+  /** The deepest label, the last of `path`. */
+  label: Leaf;
+  /** The product over the levels. */
+  probability: number;
+  confidence: number;
+  /**
+   * One entry per level. The per-level `input_chars` and `input_tokens` do not sum to
+   * `Usage.inputChars`: the header counts one pass over the body, each level re-sends the
+   * text.
+   */
+  levels: ClassifyTreeLevel[];
+}
+interface RateResult<S extends readonly string[] = readonly string[]> {
+  /** The probability-weighted position, 0 to scale.length - 1. Route on this, not `level`. */
+  score: number;
+  level: IndexOf<S>;
+  label: S[number];
+  confidence: number;
+  /** One probability per level, in scale order. */
+  scores: { -readonly [K in keyof S]: number; };
+}
+/** The service sets answer, start and end together, or nulls all three. */
+type AnswerResult<Q extends string = string> = {
+  question: Q;
+  answer: string;
+  probability: number;
+  start: number;
+  end: number;
+} | {
+  question: Q;
+  answer: null;
+  probability: number;
+  start: null;
+  end: null;
+};
+interface Entity<T extends string = string> {
+  type: T;
+  text: string;
+  probability: number;
+  start: number;
+  end: number;
+}
+interface VerifyResult {
+  matches: boolean;
+  probability: number;
+  /** What the text actually says for that field. */
+  found: string[];
+}
+type JsonSchema = {
+  readonly type?: string | readonly string[];
+  readonly [k: string]: unknown;
+};
+/** A Standard Schema object: zod 4, valibot 1.1+, arktype. */
+interface StandardSchemaV1<Output = unknown> {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: {
+      readonly input: unknown;
+      readonly output: Output;
+    };
+  };
+}
+/** A JSON Schema branded with the type it produces. */
+type Typed<T> = JsonSchema & {
+  readonly '~milliseconds.output'?: T;
+};
+type ExtractSchema = JsonSchema | StandardSchemaV1 | Typed<unknown>;
+type SchemaOutput<S> = S extends StandardSchemaV1<infer O> ? O : S extends {
+  '~milliseconds.output'?: infer T;
+} ? [unknown] extends [T] ? FromJsonSchema<S> : T : FromJsonSchema<S>;
+/** Reads a JSON Schema object literal at the type level, exactly as `kindOf` reads it. */
+type FromJsonSchema<S> = S extends {
+  enum: readonly (infer E)[];
+} ? E extends string ? E : string : S extends {
+  type: readonly (infer T extends string)[];
+} ? FromJsonSchema<Omit<S, 'type'> & {
+  type: Exclude<T, 'null'>;
+}> : S extends {
+  type: 'object';
+} ? S extends {
+  properties: infer P;
+} ? { -readonly [K in keyof P]: FromJsonSchema<P[K]>; } : Record<string, never> : S extends {
+  type: 'array';
+} ? S extends {
+  items: infer I;
+} ? I extends {
+  type: 'object';
+} ? object[] : string[] : string[] : S extends {
+  type: 'string';
+} ? string : S extends {
+  type: 'number' | 'integer';
+} ? number : S extends {
+  type: 'boolean';
+} ? boolean : S extends {
+  type: string;
+} ? undefined : string;
+/**
+ * What the runner really sends. A missing value is null. An array of objects is always [].
+ * An array of scalars arrives as strings. An enum is not checked server side. A nested
+ * object is not nullable, because `setPath` materialises it.
+ */
+type Extracted<T> = [T] extends [undefined] ? undefined : [T] extends [readonly unknown[]] ? T extends readonly (infer E)[] ? [E] extends [object] ? never[] : string[] | null : never : [T] extends [object] ? { -readonly [K in keyof T]-?: Extracted<Exclude<T[K], null | undefined>>; } : [T] extends [string] ? string extends T ? string | null : T | (string & {}) | null : T | null;
+//#endregion
+//#region src/client.d.ts
+/** Transport: fetch, retries, errors and usage. Every capability is two lines on top. */
+declare class Client {
+  #private;
+  readonly baseUrl: string;
+  constructor(options?: ClientOptions);
+  /** Escape hatch. Your path, your body, your type, the SDK's auth, retries and errors. */
+  post<R>(path: string, body: unknown, options?: CallOptions): Decision<R>;
+  /** `unwrap` maps the parsed body to the result. It follows the request, never the response. */
+  protected call<R>(path: string, body: unknown, options: CallOptions | undefined, unwrap: (raw: unknown) => R): Decision<R>;
+  private send;
+  private attempt;
+}
+//#endregion
+//#region src/decision-machine.d.ts
+/**
+ * `decision-machine-1` at api.milliseconds.ai. Every capability is a pure function, so
+ * every retry is safe.
+ */
+export declare class DecisionMachine extends Client {
+  /** Paths are `${baseUrl}/v1/${model}/<capability>`. */
+  static readonly model = "decision-machine-1";
+  /**
+   * Answers each statement with yes or no and a probability. The statements share one
+   * inference call, so extra statements are nearly free.
+   */
+  yesNo<const T extends Input, const S extends string | readonly string[]>(input: T, statements: S, options?: CallOptions & {
+    when_true?: string;
+    when_false?: string;
+  }): Decision<Fan<T, S extends readonly string[] ? { -readonly [K in keyof S]: YesNoResult<S[K] & string>; } : YesNoResult<S & string>>>;
+  /** Picks one label and returns the full distribution. Describe each label. */
+  classify<const T extends Input, const L extends Labels>(input: T, labels: L, options?: CallOptions): Decision<Fan<T, ClassifyResult<LabelOf<L>>>>;
+  /**
+   * Runs classify once per level of a nested tree, descending into the winner.
+   *
+   * The per-level `input_chars` and `input_tokens` do not sum to `Usage.inputChars`: the
+   * header counts one pass over the body, and each level re-sends the text.
+   */
+  classifyTree<const T extends Input, const N extends Tree>(input: T, tree: N, options?: CallOptions): Decision<Fan<T, ClassifyTreeResult<TreeLabels<N>, LeafLabels<N>>>>;
+  /** Places the text on an ordered scale of described levels, low to high. */
+  rate<const T extends Input, const S extends readonly string[]>(input: T, scale: S, options?: CallOptions): Decision<Fan<T, RateResult<S>>>;
+  /** Quotes the answer out of the text, with its offsets. `answer` is null when nothing fits. */
+  answer<const T extends Input, const Q extends string | readonly string[]>(input: T, questions: Q, options?: CallOptions): Decision<Fan<T, Q extends readonly string[] ? { -readonly [K in keyof Q]: AnswerResult<Q[K] & string>; } : AnswerResult<Q & string>>>;
+  /**
+   * Fills a JSON Schema from the text. Missing values are null, arrays of objects come back
+   * empty, arrays of scalars come back as strings, and enums are not checked server side.
+   */
+  extract<const T extends Input, const S extends ExtractSchema>(input: T, schema: S, options?: CallOptions): Decision<Fan<T, Extracted<SchemaOutput<S>>>>;
+  /** Finds every span matching each type, with offsets, sorted by start. */
+  entities<const T extends Input, const E extends Labels>(input: T, types: E, options?: CallOptions): Decision<Fan<T, Entity<LabelOf<E>>[]>>;
+  /** Checks whether the text says `value` for `field`. */
+  verify<const T extends Input>(input: T, field: string | {
+    name: string;
+    description?: string;
+  }, value: string | number, options?: CallOptions): Decision<Fan<T, VerifyResult>>;
+  /** `{ results }` is unwrapped for a batch, and the per-text envelope for one text. */
+  private capability;
+}
+//#endregion
+//#region src/errors.d.ts
+/** A brand property, so a duplicated copy of the package in a bundle still matches. */
+declare const BRAND = "~milliseconds.error";
+interface ErrorInit {
+  code: ErrorCode;
+  /** 0 when the call never reached the API. */
+  status?: number;
+  /** The API's own message, unchanged. */
+  apiMessage: string;
+  /** The thrown `message`: the API message plus one hint line. */
+  message?: string;
+  retryAfter?: number | null;
+  rateLimit?: RateLimit | null;
+  response?: Response | null;
+  attempts?: number;
+  retryable?: boolean;
+  cause?: unknown;
+}
+/**
+ * One error class. Switch on `code`: the union narrows exhaustively and never goes stale
+ * when the API adds a code.
+ */
+export declare class MillisecondsError extends Error {
+  readonly name = "MillisecondsError";
+  readonly [BRAND] = true;
+  readonly code: ErrorCode;
+  /** 0 when the call never reached the API. */
+  readonly status: number;
+  /** The API's own message, unchanged. `message` adds one hint line. */
+  readonly apiMessage: string;
+  /** Seconds from the retry-after header. Only 429 rate_limit_exceeded carries it. */
+  readonly retryAfter: number | null;
+  readonly rateLimit: RateLimit | null;
+  readonly response: Response | null;
+  /** Attempts this call made, including the first. */
+  readonly attempts: number;
+  /** True for the codes the SDK retries. */
+  readonly retryable: boolean;
+  constructor(init: ErrorInit);
+}
+export declare function isMillisecondsError(e: unknown): e is MillisecondsError;
+//#endregion
+//#region src/schema.d.ts
+/**
+ * Brands a JSON Schema with the type it produces. One cast, no runtime cost.
+ *
+ * `dm.extract(text, typed<z.infer<typeof S>>(z.toJSONSchema(S)))`
+ */
+export declare const typed: <T>(schema: object) => Typed<T>;
+//#endregion
+export type { AnswerResult, CallOptions, ClassifyResult, ClassifyTreeLevel, ClassifyTreeResult, ClientOptions, Decision, Entity, ErrorCode, ExtractSchema, Extracted, Fan, FromJsonSchema, IndexOf, Input, JsonSchema, LabelOf, Labels, LeafLabels, RateLimit, RateResult, SchemaOutput, StandardSchemaV1, Tree, TreeLabels, TreeNode, Typed, Usage, VerifyResult, YesNoResult };