@openmeter/client 1.0.0-beta.229 → 1.0.0-beta.231

package/dist/lib/paginate.d.ts

@@ -0,0 +1,56 @@
+import { type RequestOptions, type Result } from './types.js';
+export declare class PaginationLimitExceededError extends Error {
+    constructor(limit: number);
+}
+interface PageNumberEnvelope<TItem> {
+    data: TItem[];
+    meta: {
+        page: {
+            number: number;
+            size: number;
+            total: number;
+        };
+    };
+}
+interface PageNumberRequest {
+    page?: {
+        number?: number;
+        size?: number;
+    };
+}
+/**
+ * Iterates every item of a page-number-paginated list operation, advancing
+ * `page.number` from wherever the caller's own request starts. Every other
+ * field on `request` — filters, sort, page.size — is sent unchanged on every
+ * page fetch; only the page number advances. Stops on a page shorter than
+ * the server's own reported `size` (including an empty page) or once the
+ * running item count reaches the server's reported `total`, whichever comes
+ * first — so a final page that exactly fills `total` does not trigger one
+ * more, empty request.
+ */
+export declare function paginatePages<TItem, TReq extends PageNumberRequest>(fetchPage: (req: TReq, options?: RequestOptions) => Promise<Result<PageNumberEnvelope<TItem>>>, request: TReq, options?: RequestOptions): AsyncGenerator<TItem, void, undefined>;
+interface CursorEnvelope<TItem> {
+    data: TItem[];
+    meta: {
+        page: {
+            next?: string;
+        };
+    };
+}
+interface CursorRequest {
+    page?: {
+        after?: string;
+        before?: string;
+        size?: number;
+    };
+}
+/**
+ * Iterates every item of a cursor-paginated list operation, following
+ * `meta.page.next` until the server stops returning one. Despite carrying a
+ * `format: uri` annotation in the spec, `next` is the opaque cursor token the
+ * API expects back verbatim in `page.after` on the following request — not a
+ * URI to fetch directly. Every other field on `request` is sent unchanged on
+ * every page fetch; only `page.after` advances.
+ */
+export declare function paginateCursor<TItem, TReq extends CursorRequest>(fetchPage: (req: TReq, options?: RequestOptions) => Promise<Result<CursorEnvelope<TItem>>>, request: TReq, options?: RequestOptions): AsyncGenerator<TItem, void, undefined>;
+export {};

package/dist/lib/paginate.js

@@ -0,0 +1,60 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
+import { unwrap } from './types.js';
+// A misbehaving server — inconsistent `meta.page.total`/`size`, or a
+// `meta.page.next` cursor that never resolves to an empty page — would
+// otherwise make these generators loop forever. 10,000 pages is far beyond
+// any real OpenMeter list, so hitting it means the server's pagination
+// contract broke, not that the caller has a legitimately large list.
+const MAX_PAGINATION_PAGES = 10_000;
+export class PaginationLimitExceededError extends Error {
+    constructor(limit) {
+        super(`pagination exceeded the maximum of ${limit} pages; the server may be returning inconsistent pagination metadata`);
+        this.name = 'PaginationLimitExceededError';
+    }
+}
+/**
+ * Iterates every item of a page-number-paginated list operation, advancing
+ * `page.number` from wherever the caller's own request starts. Every other
+ * field on `request` — filters, sort, page.size — is sent unchanged on every
+ * page fetch; only the page number advances. Stops on a page shorter than
+ * the server's own reported `size` (including an empty page) or once the
+ * running item count reaches the server's reported `total`, whichever comes
+ * first — so a final page that exactly fills `total` does not trigger one
+ * more, empty request.
+ */
+export async function* paginatePages(fetchPage, request, options) {
+    let req = request;
+    let seen = 0;
+    for (let page = 0; page < MAX_PAGINATION_PAGES; page++) {
+        const res = unwrap(await fetchPage(req, options));
+        yield* res.data;
+        seen += res.data.length;
+        const { number, size, total } = res.meta.page;
+        if (res.data.length === 0 || res.data.length < size || seen >= total) {
+            return;
+        }
+        req = { ...req, page: { ...req.page, number: number + 1 } };
+    }
+    throw new PaginationLimitExceededError(MAX_PAGINATION_PAGES);
+}
+/**
+ * Iterates every item of a cursor-paginated list operation, following
+ * `meta.page.next` until the server stops returning one. Despite carrying a
+ * `format: uri` annotation in the spec, `next` is the opaque cursor token the
+ * API expects back verbatim in `page.after` on the following request — not a
+ * URI to fetch directly. Every other field on `request` is sent unchanged on
+ * every page fetch; only `page.after` advances.
+ */
+export async function* paginateCursor(fetchPage, request, options) {
+    let req = request;
+    for (let page = 0; page < MAX_PAGINATION_PAGES; page++) {
+        const res = unwrap(await fetchPage(req, options));
+        yield* res.data;
+        const next = res.meta.page.next;
+        if (!next) {
+            return;
+        }
+        req = { ...req, page: { ...req.page, after: next } };
+    }
+    throw new PaginationLimitExceededError(MAX_PAGINATION_PAGES);
+}

package/dist/lib/request.d.ts

@@ -1,3 +1,2 @@
 import { type Result } from './types.js';
 export declare function request<T>(fn: () => Promise<T>): Promise<Result<T>>;
-//# sourceMappingURL=request.d.ts.map

package/dist/lib/request.js

@@ -1,3 +1,4 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
 import { ok, err } from './types.js';
 import { toError } from './to-error.js';
 export async function request(fn) {
@@ -8,4 +9,3 @@ export async function request(fn) {
         return err(await toError(e));
     }
 }
-//# sourceMappingURL=request.js.map

package/dist/lib/to-error.d.ts

@@ -1,2 +1 @@
 export declare function toError(e: unknown): Promise<Error>;
-//# sourceMappingURL=to-error.d.ts.map

package/dist/lib/to-error.js

@@ -1,3 +1,4 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
 import { HTTPError as KyHTTPError } from 'ky';
 import * as schemas from '../models/schemas.js';
 import { HTTPError } from '../models/errors.js';
@@ -13,4 +14,3 @@ export async function toError(e) {
     }
     return new Error(String(e));
 }
-//# sourceMappingURL=to-error.js.map

package/dist/lib/types.d.ts

@@ -12,4 +12,3 @@ export type Result<T, E = Error> = {
 export declare function ok<T>(value: T): Result<T, never>;
 export declare function err<E>(error: E): Result<never, E>;
 export declare function unwrap<T, E>(result: Result<T, E>): T;
-//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.js

@@ -1,3 +1,4 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
 export function ok(value) {
     return { ok: true, value };
 }
@@ -10,4 +11,3 @@ export function unwrap(result) {
     }
     throw result.error;
 }
-//# sourceMappingURL=types.js.map

package/dist/lib/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "v1.0.0-beta.231";

package/dist/lib/version.js

@@ -0,0 +1,5 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
+// The committed value is a dev placeholder. The publish flow
+// (`make -C api/spec publish-aip-sdk`) stamps the real release version here
+// before `pnpm publish`, after `pnpm version` updates package.json.
+export const SDK_VERSION = 'v1.0.0-beta.231';

package/dist/lib/wire.d.ts

@@ -0,0 +1,20 @@
+import type { output, ZodType } from 'zod';
+export declare function toCamelCase(name: string): string;
+export declare function toSnakeCase(name: string): string;
+export declare class UnsafeIntegerError extends Error {
+    constructor(value: bigint);
+}
+export type DateString = string & Record<never, never>;
+export type AcceptDateStrings<T> = T extends Date ? Date | DateString : T extends (infer E)[] ? AcceptDateStrings<E>[] : T extends object ? {
+    [K in keyof T]: AcceptDateStrings<T[K]>;
+} : T;
+export declare class DepthLimitExceededError extends Error {
+    constructor();
+}
+export declare function toWire<T>(data: T, schema: ZodType): T;
+export declare function fromWire<S extends ZodType>(data: unknown, schema: S): output<S>;
+export declare class ValidationError extends Error {
+    readonly issues: unknown;
+    constructor(message: string, issues: unknown);
+}
+export declare function assertValid(schema: ZodType, data: unknown): void;

package/dist/lib/wire.js

@@ -0,0 +1,401 @@
+// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.
+export function toCamelCase(name) {
+    return name.replace(/_([a-z0-9])/g, (_m, c) => c.toUpperCase());
+}
+export function toSnakeCase(name) {
+    return name.replace(/([A-Z])/g, (_m, c) => `_${c.toLowerCase()}`);
+}
+function def(schema) {
+    return schema?.def;
+}
+// Unwrap optional/nullable/default to the schema that describes the value's
+// shape. These wrappers never change keys, so the walker looks through them
+// before classifying a node.
+function unwrap(schema) {
+    let current = schema;
+    for (let i = 0; i < 100 && current; i++) {
+        const d = def(current);
+        if (d &&
+            (d.type === 'optional' ||
+                d.type === 'nullable' ||
+                d.type === 'default') &&
+            d.innerType) {
+            current = d.innerType;
+            continue;
+        }
+        return current;
+    }
+    /* v8 ignore next -- loop returns inside; reached only past the cycle guard */
+    return current;
+}
+// The default to write for a field the caller omitted, present only when the
+// field is required-with-default in the spec — emitted as `.default(x)` with no
+// `.optional()` in the wrapper chain (TypeSpec `field: T = x`, not
+// `field?: T = x`). Such fields must be present on the wire (e.g. a CloudEvents
+// envelope's `specversion`, which the server's parser rejects when absent), yet
+// the generated request type allows omitting them so callers get the documented
+// default for free — toWire is the layer that has to reconcile the two.
+// Spec-optional fields (`.optional().default(x)`) return undefined and stay off
+// the wire: their default is the server's to apply, and materializing them
+// client-side would silently overwrite server state on update requests.
+function requiredDefault(schema) {
+    let current = schema;
+    let found;
+    for (let i = 0; i < 100 && current; i++) {
+        const d = def(current);
+        /* v8 ignore next 3 -- every zod schema carries a def; guards the type only */
+        if (!d) {
+            break;
+        }
+        if (d.type === 'optional') {
+            return undefined;
+        }
+        if (d.type === 'default') {
+            found ??= { value: d.defaultValue };
+        }
+        else if (d.type !== 'nullable') {
+            break;
+        }
+        current = d.innerType;
+    }
+    return found;
+}
+function shapeOf(schema) {
+    return schema?.shape;
+}
+// The element schema for array data: the schema's own element when it is an
+// array, or the array variant's element when it is a union of T and T[]
+// (the single-or-batch body shape).
+function arrayElement(schema) {
+    const d = def(schema);
+    if (d?.type === 'array') {
+        return d.element;
+    }
+    if (d?.type === 'union') {
+        for (const option of d.options ?? []) {
+            const od = def(unwrap(option));
+            if (od?.type === 'array') {
+                return od.element;
+            }
+        }
+    }
+    return undefined;
+}
+// Whether a record value schema needs walking: it carries renamable fields
+// (object/record/array/union of such) or date-typed values that must map
+// between `Date` and the RFC 3339 wire string. Other scalars, literals,
+// unknown, and any are left untouched, so user data (labels, dimensions,
+// event payloads) is never rewritten.
+function needsWalk(schema) {
+    const s = unwrap(schema);
+    const d = def(s);
+    /* v8 ignore next 3 -- a record always has a value schema; defensive only */
+    if (!d) {
+        return false;
+    }
+    if (d.type === 'object' ||
+        d.type === 'record' ||
+        d.type === 'date' ||
+        d.type === 'bigint') {
+        return true;
+    }
+    if (d.type === 'array') {
+        return needsWalk(d.element);
+    }
+    if (d.type === 'union') {
+        return (d.options ?? []).some(needsWalk);
+    }
+    return false;
+}
+// Thrown by toWire when a bigint value (an int64/uint64 field) is outside
+// JSON's exactly-representable integer range. The wire carries int64 as a JSON
+// number (the server decodes it into a Go int64), so a value beyond 2^53-1
+// cannot be sent without silent precision corruption — a typed, immediate
+// failure is the only honest option. request() catches it like any Error and
+// surfaces it as Result.error.
+export class UnsafeIntegerError extends Error {
+    constructor(value) {
+        super(`bigint value ${value} exceeds JSON's safe integer range and cannot be sent without precision loss`);
+        this.name = 'UnsafeIntegerError';
+    }
+}
+const _literalsSurviveWidening = true;
+void _literalsSurviveWidening;
+// A handful of schemas are genuinely self-referential (e.g. the `and`/`or`
+// legs of a filter tree), so nesting depth is bounded only by the DATA the
+// server sends, not by the schema. Without a limit, a crafted or
+// accidentally-deep response recurses until the JS engine throws a raw
+// `RangeError: Maximum call stack size exceeded` — still caught by request()
+// and surfaced as Result.error, but as an opaque native error instead of a
+// typed one. 500 levels is far beyond any real filter/record/array nesting
+// in the API today; it exists to fail predictably, not to constrain valid data.
+const MAX_WALK_DEPTH = 500;
+export class DepthLimitExceededError extends Error {
+    constructor() {
+        super(`wire mapping exceeded maximum nesting depth (${MAX_WALK_DEPTH})`);
+        this.name = 'DepthLimitExceededError';
+    }
+}
+function walk(data, schema, dir, depth = 0) {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    // A Date can only ever mean its wire serialization, wherever it sits — a
+    // typed date field, a record value, or an unknown-schema position. Wire→
+    // public data never contains Date instances (it comes from JSON.parse), so
+    // this only rewrites public→wire. The same holds for bigint: JSON.parse
+    // never produces one, and public→wire it must become a JSON number wherever
+    // it sits.
+    if (data instanceof Date) {
+        return dir.mapDate(data);
+    }
+    if (typeof data === 'bigint') {
+        return dir.mapBigInt(data);
+    }
+    if (depth > MAX_WALK_DEPTH) {
+        throw new DepthLimitExceededError();
+    }
+    const s = unwrap(schema);
+    const d = def(s);
+    // A date-typed node maps between the public `Date` and the RFC 3339 wire
+    // string (fromWire revives the string; a string handed to toWire by an
+    // untyped caller passes through as-is).
+    if (d?.type === 'date') {
+        return dir.mapDate(data);
+    }
+    // A bigint-typed node revives the wire's JSON number into the public
+    // `bigint` (public→wire bigints were already mapped by the value check
+    // above, so only fromWire reaches a number here).
+    if (d?.type === 'bigint') {
+        return dir.mapBigInt(data);
+    }
+    if (Array.isArray(data)) {
+        // The schema may be the array itself or a union with an array variant
+        // (e.g. a single-or-batch body `T | T[]`); resolve the element schema from
+        // whichever applies so array items are still walked with their shape.
+        const element = arrayElement(s);
+        return data.map((item) => walk(item, element, dir, depth + 1));
+    }
+    if (typeof data !== 'object') {
+        // A wire datetime can sit behind a union (`DateTime | null`,
+        // enum-or-DateTime): revive the string only when the union's date variant
+        // is its sole plausible owner, so enum literals and plain-string variants
+        // pass through untouched.
+        if (typeof data === 'string' &&
+            d?.type === 'union' &&
+            unionDateClaims(s, data)) {
+            return dir.mapDate(data);
+        }
+        return data;
+    }
+    const record = data;
+    if (d?.type === 'record') {
+        // Record keys are user data (label/dimension names) — preserved verbatim.
+        // Only the value is walked, and only when it needs mapping. A null
+        // prototype avoids the `__proto__` key silently reassigning `out`'s own
+        // prototype instead of becoming a visible entry (user data may contain
+        // any key, including reserved object-literal property names). The
+        // prototype is restored once every key is a plain own property, so the
+        // returned object still behaves normally for consumers (instanceof,
+        // template literals) — `Object.prototype` itself was never touched.
+        const valueSchema = needsWalk(d.valueType) ? d.valueType : undefined;
+        const out = Object.create(null);
+        for (const [key, value] of Object.entries(record)) {
+            out[key] = valueSchema ? walk(value, valueSchema, dir, depth + 1) : value;
+        }
+        Object.setPrototypeOf(out, Object.prototype);
+        return out;
+    }
+    if (d?.type === 'union') {
+        const variant = selectVariant(record, s, dir);
+        if (!variant) {
+            // No confident match: leave keys untransformed rather than guess.
+            return data;
+        }
+        return walk(data, variant, dir, depth + 1);
+    }
+    if (d?.type === 'object') {
+        const shape = shapeOf(s) ?? {};
+        // A null prototype avoids two failure modes from data-controlled keys
+        // like `__proto__`/`constructor`: (1) `fieldFor` below reading an
+        // inherited Object.prototype member instead of correctly treating the
+        // key as schema-undeclared, and (2) the assignment at the end of this
+        // loop reassigning `out`'s own prototype instead of adding a visible key.
+        const out = Object.create(null);
+        for (const [key, value] of Object.entries(record)) {
+            const fieldSchema = fieldFor(shape, key);
+            // Keys the schema does not declare are dropped, so the result matches the
+            // typed shape exactly (a server-added field has no place in the type).
+            if (fieldSchema === undefined) {
+                continue;
+            }
+            out[dir.rename(key)] = walk(value, fieldSchema, dir, depth + 1);
+        }
+        if (dir.applyDefaults) {
+            // Shape keys are generated camelCase identifiers (never data-controlled),
+            // so direct indexing into `record` is safe here. Runs after the data loop
+            // so an explicit `key: undefined` entry is also replaced by the default.
+            for (const [key, fieldSchema] of Object.entries(shape)) {
+                if (record[key] !== undefined) {
+                    continue;
+                }
+                const dflt = requiredDefault(fieldSchema);
+                if (dflt !== undefined) {
+                    out[dir.rename(key)] = walk(dflt.value, fieldSchema, dir, depth + 1);
+                }
+            }
+        }
+        Object.setPrototypeOf(out, Object.prototype);
+        return out;
+    }
+    // Scalar or unknown schema: pass through untransformed.
+    return data;
+}
+// Resolve a data key to its field schema. The schema is camelCase-keyed; a
+// wire→public data key is snake, so it is camelized to index the shape.
+// Own-property checks (not `shape[key]`) so a data-controlled key like
+// `__proto__` or `constructor` cannot resolve to an inherited
+// Object.prototype member and be mistaken for a declared schema field.
+function fieldFor(shape, dataKey) {
+    if (Object.hasOwn(shape, dataKey)) {
+        return shape[dataKey];
+    }
+    const camelKey = toCamelCase(dataKey);
+    return Object.hasOwn(shape, camelKey) ? shape[camelKey] : undefined;
+}
+function selectVariant(data, schema, dir) {
+    const d = def(schema);
+    const options = d?.options ?? [];
+    if (d?.discriminator && schema) {
+        // O(1) dispatch on the discriminator literal. The data key is the wire-name in
+        // fromWire (snake) and the public name in toWire (camel); the variant map is
+        // keyed by the literal value, which is identical in both directions.
+        const dataKey = dir.discriminatorKey(d.discriminator);
+        return variantsByDiscriminator(schema, d).get(data[dataKey]);
+    }
+    // Non-discriminated union: the codegen gate guarantees at most one object
+    // variant (it fails the build for a mapped union with two or more), so the single
+    // object-shaped option is unambiguous. Other variants (scalars, arrays) reach the
+    // walk through their own data-kind branches, not here.
+    return options.find((option) => def(unwrap(option))?.type === 'object');
+}
+// Memoized literal→variant map for a discriminated union, built once per schema.
+const variantMapCache = new WeakMap();
+function variantsByDiscriminator(schema, d) {
+    const cached = variantMapCache.get(schema);
+    if (cached) {
+        return cached;
+    }
+    const map = new Map();
+    for (const option of d.options ?? []) {
+        const shape = shapeOf(unwrap(option));
+        const literal = literalValue(shape?.[d.discriminator]);
+        if (literal !== undefined) {
+            map.set(literal, option);
+        }
+    }
+    variantMapCache.set(schema, map);
+    return map;
+}
+function literalValue(schema) {
+    const s = unwrap(schema);
+    if (def(s)?.type === 'literal') {
+        return s.value;
+    }
+    /* v8 ignore next -- a discriminated-union variant's discriminator is a literal */
+    return undefined;
+}
+// Whether a union's date variant is the sole plausible owner of a string
+// value: the union carries a date option, no string-capable sibling (a plain
+// string variant, an enum containing the value, an equal string literal)
+// claims it, and the value actually parses as a date. `DateTime | null`
+// revives its RFC 3339 string; `'immediate' | DateTime` keeps the enum
+// literal a string. Fail-open: an unclaimed string stays a string.
+function unionDateClaims(schema, value) {
+    let hasDate = false;
+    for (const option of def(schema)?.options ?? []) {
+        const od = def(unwrap(option));
+        if (od?.type === 'date') {
+            hasDate = true;
+        }
+        else if (od?.type === 'string') {
+            return false;
+        }
+        else if (od?.type === 'enum' &&
+            Object.values(od.entries ?? {}).includes(value)) {
+            return false;
+        }
+        else if (od?.type === 'literal' && literalValue(option) === value) {
+            return false;
+        }
+    }
+    return hasDate && !Number.isNaN(Date.parse(value));
+}
+const toWireDirection = {
+    rename: toSnakeCase,
+    discriminatorKey: (camelKey) => camelKey,
+    mapDate: (value) => (value instanceof Date ? value.toISOString() : value),
+    mapBigInt: (value) => {
+        if (typeof value !== 'bigint') {
+            return value;
+        }
+        if (value > BigInt(Number.MAX_SAFE_INTEGER) ||
+            value < -BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new UnsafeIntegerError(value);
+        }
+        return Number(value);
+    },
+    applyDefaults: true,
+};
+const fromWireDirection = {
+    rename: toCamelCase,
+    discriminatorKey: (camelKey) => toSnakeCase(camelKey),
+    mapDate: (value) => (typeof value === 'string' ? new Date(value) : value),
+    mapBigInt: (value) => typeof value === 'number' && Number.isInteger(value)
+        ? BigInt(value)
+        : value,
+    applyDefaults: false,
+};
+// Rewrite a request body or query object from the camelCase public shape to the
+// snake_case wire shape, driven by its schema. Record keys (label/dimension names)
+// are preserved; `Date` values serialize to RFC 3339 strings; `bigint` values
+// (int64 fields) become JSON numbers; omitted required-with-default fields are
+// filled with their declared default (see requiredDefault). The return is typed
+// as the input `T` so call sites stay cast-free (the runtime object has snake keys
+// and wire-encoded dates, but the value is write-only — it flows straight into
+// `json:`/`toURLSearchParams`, both of which accept any object).
+export function toWire(data, schema) {
+    return walk(data, schema, toWireDirection);
+}
+// Rewrite a response body from the snake_case wire shape to the camelCase public
+// shape: renames keys and revives RFC 3339 strings into `Date`s at date-typed
+// nodes — never applies defaults or any other coercion. The result is the
+// schema's output shape: `walk` produces exactly the schema's known fields in
+// camelCase, so the inferred `output<S>` type describes the runtime value (the
+// same wire-trust boundary as a plain `.json<T>()`, with no `.parse()`).
+export function fromWire(data, schema) {
+    return walk(data, schema, fromWireDirection);
+}
+// Thrown by assertValid when the optional `validate` client option is on and data
+// fails its schema. request() catches it like any Error and surfaces it as
+// Result.error.
+export class ValidationError extends Error {
+    issues;
+    constructor(message, issues) {
+        super(message);
+        this.issues = issues;
+        this.name = 'ValidationError';
+    }
+}
+// Opt-in schema check used by the funcs (when the validate option is on) against
+// the snake_case wire payload: the request body after toWire, the raw response
+// before fromWire, each against its generated `…Wire` schema. It is a GATE, not a
+// transform — the safeParse output (coercions/defaults) is discarded, so validation
+// never mutates the payload or return value. Off by default; the SDK does not
+// validate by default (additive server fields must not break clients).
+export function assertValid(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new ValidationError('schema validation failed', result.error.issues);
+    }
+}

package/dist/models/errors.d.ts

@@ -5,12 +5,23 @@ export declare class HTTPError extends Error {
     title: string;
     status: number;
     url: string;
+    retryAfter: number | undefined;
     protected __raw?: Record<string, unknown> | undefined;
-    constructor(message: string, type: string, title: string, status: number, url: string, __raw?: Record<string, unknown> | undefined);
+    constructor(message: string, type: string, title: string, status: number, url: string, retryAfter: number | undefined, __raw?: Record<string, unknown> | undefined);
     static fromResponse(resp: {
         response: Response;
         error?: z.infer<typeof schemas.baseError>;
     }): HTTPError;
+    /**
+     * The `invalid_parameters` problem-detail extension member, present on Bad
+     * Request (400) responses. Typed from the schema, not runtime-validated
+     * (like the rest of the SDK, this trusts the server rather than rejecting
+     * additive fields) — `undefined` when the response didn't carry one.
+     */
+    get invalidParameters(): z.infer<typeof schemas.invalidParameters> | undefined;
+    /**
+     * Escape hatch for problem-detail extension members without a typed
+     * accessor above.
+     */
     getField(key: string): unknown;
 }
-//# sourceMappingURL=errors.d.ts.map