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

package/dist/lib/wire.js

@@ -0,0 +1,312 @@
+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;
+}
+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') {
+        return true;
+    }
+    if (d.type === 'array') {
+        return needsWalk(d.element);
+    }
+    if (d.type === 'union') {
+        return (d.options ?? []).some(needsWalk);
+    }
+    return false;
+}
+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.
+    if (data instanceof Date) {
+        return dir.mapDate(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);
+    }
+    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);
+        }
+        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),
+};
+const fromWireDirection = {
+    rename: toCamelCase,
+    discriminatorKey: (camelKey) => toSnakeCase(camelKey),
+    mapDate: (value) => (typeof value === 'string' ? new Date(value) : value),
+};
+// 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. 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);
+    }
+}
+//# sourceMappingURL=wire.js.map

package/dist/models/operations/addons.d.ts

@@ -1,3 +1,4 @@
+import type { AcceptDateStrings } from '../../lib/wire.js';
 import type { Addon, AddonPagePaginatedResponse, CreateAddonRequestInput, ListAddonsParamsFilter, SortQueryInput, UpsertAddonRequestInput } from '../types.js';
 export interface ListAddonsQuery {
     /** Determines which page of the collection to retrieve. */
@@ -5,19 +6,30 @@ export interface ListAddonsQuery {
         size?: number;
         number?: number;
     };
-    /** Sort add-ons returned in the response. Supported sort attributes are: - `id` - `key` - `name` - `created_at` (default) - `updated_at` The `asc` suffix is optional as the default sort order is ascending. The `desc` suffix is used to specify a descending order. */
+    /**
+     * Sort add-ons returned in the response. Supported sort attributes are:
+     *
+     * - `id`
+     * - `key`
+     * - `name`
+     * - `created_at` (default)
+     * - `updated_at`
+     *
+     * The `asc` suffix is optional as the default sort order is ascending. The `desc`
+     * suffix is used to specify a descending order.
+     */
     sort?: SortQueryInput;
     /** Filter add-ons returned in the response. */
     filter?: ListAddonsParamsFilter;
 }
-export type ListAddonsRequest = ListAddonsQuery;
+export type ListAddonsRequest = AcceptDateStrings<ListAddonsQuery>;
 export type ListAddonsResponse = AddonPagePaginatedResponse;
-export type CreateAddonRequest = CreateAddonRequestInput;
+export type CreateAddonRequest = AcceptDateStrings<CreateAddonRequestInput>;
 export type CreateAddonResponse = Addon;
-export type UpdateAddonRequest = {
+export type UpdateAddonRequest = AcceptDateStrings<{
     addonId: string;
     body: UpsertAddonRequestInput;
-};
+}>;
 export type UpdateAddonResponse = Addon;
 export type GetAddonRequest = {
     addonId: string;

package/dist/models/operations/apps.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import * as schemas from '../schemas.js';
+import type { AcceptDateStrings } from '../../lib/wire.js';
 import type { AppPagePaginatedResponse } from '../types.js';
 export interface ListAppsQuery {
     /** Determines which page of the collection to retrieve. */
@@ -8,7 +9,7 @@ export interface ListAppsQuery {
         number?: number;
     };
 }
-export type ListAppsRequest = ListAppsQuery;
+export type ListAppsRequest = AcceptDateStrings<ListAppsQuery>;
 export type ListAppsResponse = AppPagePaginatedResponse;
 export type GetAppRequest = {
     appId: string;

package/dist/models/operations/billing.d.ts

@@ -1,3 +1,4 @@
+import type { AcceptDateStrings } from '../../lib/wire.js';
 import type { CreateBillingProfileRequestInput, Profile, ProfilePagePaginatedResponse, UpsertBillingProfileRequestInput } from '../types.js';
 export interface ListBillingProfilesQuery {
     /** Determines which page of the collection to retrieve. */
@@ -6,18 +7,18 @@ export interface ListBillingProfilesQuery {
         number?: number;
     };
 }
-export type ListBillingProfilesRequest = ListBillingProfilesQuery;
+export type ListBillingProfilesRequest = AcceptDateStrings<ListBillingProfilesQuery>;
 export type ListBillingProfilesResponse = ProfilePagePaginatedResponse;
-export type CreateBillingProfileRequest = CreateBillingProfileRequestInput;
+export type CreateBillingProfileRequest = AcceptDateStrings<CreateBillingProfileRequestInput>;
 export type CreateBillingProfileResponse = Profile;
 export type GetBillingProfileRequest = {
     id: string;
 };
 export type GetBillingProfileResponse = Profile;
-export type UpdateBillingProfileRequest = {
+export type UpdateBillingProfileRequest = AcceptDateStrings<{
     id: string;
     body: UpsertBillingProfileRequestInput;
-};
+}>;
 export type UpdateBillingProfileResponse = Profile;
 export type DeleteBillingProfileRequest = {
     id: string;

package/dist/models/operations/currencies.d.ts

@@ -1,3 +1,4 @@
+import type { AcceptDateStrings } from '../../lib/wire.js';
 import type { CostBasis, CostBasisPagePaginatedResponse, CreateCostBasisRequest as CreateCostBasisRequestBody, CreateCurrencyCustomRequest, CurrencyCustom, CurrencyPagePaginatedResponse, ListCostBasesParamsFilter, ListCurrenciesParamsFilter, SortQueryInput } from '../types.js';
 export interface ListCurrenciesQuery {
     /** Determines which page of the collection to retrieve. */
@@ -5,17 +6,34 @@ export interface ListCurrenciesQuery {
         size?: number;
         number?: number;
     };
-    /** Sort currencies returned in the response. Supported sort attributes are: - `code` (default) - `name` The `asc` suffix is optional as the default sort order is ascending. The `desc` suffix is used to specify a descending order. */
+    /**
+     * Sort currencies returned in the response. Supported sort attributes are:
+     *
+     * - `code` (default)
+     * - `name`
+     *
+     * The `asc` suffix is optional as the default sort order is ascending. The `desc`
+     * suffix is used to specify a descending order.
+     */
     sort?: SortQueryInput;
-    /** Filter currencies returned in the response. To filter currencies by type add the following query param: filter[type]=custom */
+    /**
+     * Filter currencies returned in the response.
+     *
+     * To filter currencies by type add the following query param: filter[type]=custom
+     */
     filter?: ListCurrenciesParamsFilter;
 }
-export type ListCurrenciesRequest = ListCurrenciesQuery;
+export type ListCurrenciesRequest = AcceptDateStrings<ListCurrenciesQuery>;
 export type ListCurrenciesResponse = CurrencyPagePaginatedResponse;
-export type CreateCustomCurrencyRequest = CreateCurrencyCustomRequest;
+export type CreateCustomCurrencyRequest = AcceptDateStrings<CreateCurrencyCustomRequest>;
 export type CreateCustomCurrencyResponse = CurrencyCustom;
 export interface ListCostBasesQuery {
-    /** Filter cost bases returned in the response. To filter cost bases by fiat currency code add the following query param: filter[fiat_code]=USD */
+    /**
+     * Filter cost bases returned in the response.
+     *
+     * To filter cost bases by fiat currency code add the following query param:
+     * filter[fiat_code]=USD
+     */
     filter?: ListCostBasesParamsFilter;
     /** Determines which page of the collection to retrieve. */
     page?: {
@@ -23,13 +41,13 @@ export interface ListCostBasesQuery {
         number?: number;
     };
 }
-export type ListCostBasesRequest = ListCostBasesQuery & {
+export type ListCostBasesRequest = AcceptDateStrings<ListCostBasesQuery & {
     currencyId: string;
-};
+}>;
 export type ListCostBasesResponse = CostBasisPagePaginatedResponse;
-export type CreateCostBasisRequest = {
+export type CreateCostBasisRequest = AcceptDateStrings<{
     currencyId: string;
     body: CreateCostBasisRequestBody;
-};
+}>;
 export type CreateCostBasisResponse = CostBasis;
 //# sourceMappingURL=currencies.d.ts.map

package/dist/models/operations/customers.d.ts

@@ -1,5 +1,8 @@
-import type { AppCustomerData, AppStripeCreateCheckoutSessionResult, AppStripeCreateCustomerPortalSessionResult, ChargePagePaginatedResponse, CreateCreditAdjustmentRequest as CreateCreditAdjustmentRequestBody, CreateCreditGrantRequestInput, CreateCustomerRequest as CreateCustomerRequestBody, CreditAdjustment, CreditBalances, CreditGrant, CreditGrantPagePaginatedResponse, CreditTransactionPaginatedResponse, CursorPaginationQueryPage, Customer, CustomerData, CustomerPagePaginatedResponse, CustomerStripeCreateCheckoutSessionRequestInput, CustomerStripeCreateCustomerPortalSessionRequest, GetCreditBalanceParamsFilter, ListChargesParamsFilter, ListCreditGrantsParamsFilter, ListCreditTransactionsParamsFilter, ListCustomersParamsFilter, SortQueryInput, UpsertAppCustomerDataRequest, UpsertCustomerBillingDataRequest, UpsertCustomerRequest as UpsertCustomerRequestBody } from '../types.js';
-export type CreateCustomerRequest = CreateCustomerRequestBody;
+import { z } from 'zod';
+import * as schemas from '../schemas.js';
+import type { AcceptDateStrings } from '../../lib/wire.js';
+import type { AppCustomerData, AppStripeCreateCheckoutSessionResult, AppStripeCreateCustomerPortalSessionResult, ChargePagePaginatedResponse, CreateChargeFlatFeeRequest, CreateChargeUsageBasedRequest, CreateCreditAdjustmentRequest as CreateCreditAdjustmentRequestBody, CreateCreditGrantRequestInput, CreateCustomerRequest as CreateCustomerRequestBody, CreditAdjustment, CreditBalances, CreditGrant, CreditGrantPagePaginatedResponse, CreditTransactionPaginatedResponse, CursorPaginationQueryPage, Customer, CustomerData, CustomerPagePaginatedResponse, CustomerStripeCreateCheckoutSessionRequestInput, CustomerStripeCreateCustomerPortalSessionRequest, GetCreditBalanceParamsFilter, ListChargesParamsFilter, ListCreditGrantsParamsFilter, ListCreditTransactionsParamsFilter, ListCustomersParamsFilter, SortQueryInput, UpdateCreditGrantExternalSettlementRequest as UpdateCreditGrantExternalSettlementRequestBody, UpsertAppCustomerDataRequest, UpsertCustomerBillingDataRequest, UpsertCustomerRequest as UpsertCustomerRequestBody } from '../types.js';
+export type CreateCustomerRequest = AcceptDateStrings<CreateCustomerRequestBody>;
 export type CreateCustomerResponse = Customer;
 export type GetCustomerRequest = {
     customerId: string;
@@ -11,17 +14,30 @@ export interface ListCustomersQuery {
         size?: number;
         number?: number;
     };
-    /** Sort customers returned in the response. Supported sort attributes are: - `id` - `name` (default) - `created_at` The `asc` suffix is optional as the default sort order is ascending. The `desc` suffix is used to specify a descending order. */
+    /**
+     * Sort customers returned in the response. Supported sort attributes are:
+     *
+     * - `id`
+     * - `name` (default)
+     * - `created_at`
+     *
+     * The `asc` suffix is optional as the default sort order is ascending. The `desc`
+     * suffix is used to specify a descending order.
+     */
     sort?: SortQueryInput;
-    /** Filter customers returned in the response. To filter customers by key add the following query param: filter[key]=my-db-id */
+    /**
+     * Filter customers returned in the response.
+     *
+     * To filter customers by key add the following query param: filter[key]=my-db-id
+     */
     filter?: ListCustomersParamsFilter;
 }
-export type ListCustomersRequest = ListCustomersQuery;
+export type ListCustomersRequest = AcceptDateStrings<ListCustomersQuery>;
 export type ListCustomersResponse = CustomerPagePaginatedResponse;
-export type UpsertCustomerRequest = {
+export type UpsertCustomerRequest = AcceptDateStrings<{
     customerId: string;
     body: UpsertCustomerRequestBody;
-};
+}>;
 export type UpsertCustomerResponse = Customer;
 export type DeleteCustomerRequest = {
     customerId: string;
@@ -31,30 +47,30 @@ export type GetCustomerBillingRequest = {
     customerId: string;
 };
 export type GetCustomerBillingResponse = CustomerData;
-export type UpdateCustomerBillingRequest = {
+export type UpdateCustomerBillingRequest = AcceptDateStrings<{
     customerId: string;
     body: UpsertCustomerBillingDataRequest;
-};
+}>;
 export type UpdateCustomerBillingResponse = CustomerData;
-export type UpdateCustomerBillingAppDataRequest = {
+export type UpdateCustomerBillingAppDataRequest = AcceptDateStrings<{
     customerId: string;
     body: UpsertAppCustomerDataRequest;
-};
+}>;
 export type UpdateCustomerBillingAppDataResponse = AppCustomerData;
-export type CreateCustomerStripeCheckoutSessionRequest = {
+export type CreateCustomerStripeCheckoutSessionRequest = AcceptDateStrings<{
     customerId: string;
     body: CustomerStripeCreateCheckoutSessionRequestInput;
-};
+}>;
 export type CreateCustomerStripeCheckoutSessionResponse = AppStripeCreateCheckoutSessionResult;
-export type CreateCustomerStripePortalSessionRequest = {
+export type CreateCustomerStripePortalSessionRequest = AcceptDateStrings<{
     customerId: string;
     body: CustomerStripeCreateCustomerPortalSessionRequest;
-};
+}>;
 export type CreateCustomerStripePortalSessionResponse = AppStripeCreateCustomerPortalSessionResult;
-export type CreateCreditGrantRequest = {
+export type CreateCreditGrantRequest = AcceptDateStrings<{
     customerId: string;
     body: CreateCreditGrantRequestInput;
-};
+}>;
 export type CreateCreditGrantResponse = CreditGrant;
 export type GetCreditGrantRequest = {
     customerId: string;
@@ -70,32 +86,42 @@ export interface ListCreditGrantsQuery {
     /** Filter credit grants returned in the response. */
     filter?: ListCreditGrantsParamsFilter;
 }
-export type ListCreditGrantsRequest = ListCreditGrantsQuery & {
+export type ListCreditGrantsRequest = AcceptDateStrings<ListCreditGrantsQuery & {
     customerId: string;
-};
+}>;
 export type ListCreditGrantsResponse = CreditGrantPagePaginatedResponse;
 export interface GetCustomerCreditBalanceQuery {
-    /** Return the credit balance as of this timestamp. Defaults to the current time. */
-    timestamp?: string;
+    /**
+     * Return the credit balance as of this timestamp.
+     *
+     * Defaults to the current time.
+     */
+    timestamp?: Date;
     filter?: GetCreditBalanceParamsFilter;
 }
-export type GetCustomerCreditBalanceRequest = GetCustomerCreditBalanceQuery & {
+export type GetCustomerCreditBalanceRequest = AcceptDateStrings<GetCustomerCreditBalanceQuery & {
     customerId: string;
-};
+}>;
 export type GetCustomerCreditBalanceResponse = CreditBalances;
-export type CreateCreditAdjustmentRequest = {
+export type CreateCreditAdjustmentRequest = AcceptDateStrings<{
     customerId: string;
     body: CreateCreditAdjustmentRequestBody;
-};
+}>;
 export type CreateCreditAdjustmentResponse = CreditAdjustment;
+export type UpdateCreditGrantExternalSettlementRequest = AcceptDateStrings<{
+    customerId: string;
+    creditGrantId: string;
+    body: UpdateCreditGrantExternalSettlementRequestBody;
+}>;
+export type UpdateCreditGrantExternalSettlementResponse = CreditGrant;
 export interface ListCreditTransactionsQuery {
     page?: CursorPaginationQueryPage;
     /** Filter credit transactions returned in the response. */
     filter?: ListCreditTransactionsParamsFilter;
 }
-export type ListCreditTransactionsRequest = ListCreditTransactionsQuery & {
+export type ListCreditTransactionsRequest = AcceptDateStrings<ListCreditTransactionsQuery & {
     customerId: string;
-};
+}>;
 export type ListCreditTransactionsResponse = CreditTransactionPaginatedResponse;
 export interface ListCustomerChargesQuery {
     /** Determines which page of the collection to retrieve. */
@@ -103,15 +129,40 @@ export interface ListCustomerChargesQuery {
         size?: number;
         number?: number;
     };
-    /** Sort charges returned in the response. Supported sort attributes are: - `id` - `created_at` - `service_period.from` - `billing_period.from` */
+    /**
+     * Sort charges returned in the response.
+     *
+     * Supported sort attributes are:
+     *
+     * - `id`
+     * - `created_at`
+     * - `service_period.from`
+     * - `billing_period.from`
+     */
     sort?: SortQueryInput;
-    /** Filter charges. To filter charges by status add the following query param: `filter[status][oeq]=created,active` */
+    /**
+     * Filter charges.
+     *
+     * To filter charges by status add the following query param:
+     * `filter[status][oeq]=created,active`
+     */
     filter?: ListChargesParamsFilter;
-    /** Expand full objects for referenced entities. Supported values are: - `real_time_usage`: Expand the charge's real-time usage. */
+    /**
+     * Expand full objects for referenced entities.
+     *
+     * Supported values are:
+     *
+     * - `real_time_usage`: Expand the charge's real-time usage.
+     */
     expand?: 'real_time_usage'[];
 }
-export type ListCustomerChargesRequest = ListCustomerChargesQuery & {
+export type ListCustomerChargesRequest = AcceptDateStrings<ListCustomerChargesQuery & {
     customerId: string;
-};
+}>;
 export type ListCustomerChargesResponse = ChargePagePaginatedResponse;
+export type CreateCustomerChargesRequest = AcceptDateStrings<{
+    customerId: string;
+    body: CreateChargeFlatFeeRequest | CreateChargeUsageBasedRequest;
+}>;
+export type CreateCustomerChargesResponse = z.output<typeof schemas.createCustomerChargesResponse>;
 //# sourceMappingURL=customers.d.ts.map

package/dist/models/operations/defaults.d.ts

@@ -1,6 +1,7 @@
+import type { AcceptDateStrings } from '../../lib/wire.js';
 import type { OrganizationDefaultTaxCodes, UpdateOrganizationDefaultTaxCodesRequest as UpdateOrganizationDefaultTaxCodesRequestBody } from '../types.js';
 export type GetOrganizationDefaultTaxCodesRequest = Record<string, never>;
 export type GetOrganizationDefaultTaxCodesResponse = OrganizationDefaultTaxCodes;
-export type UpdateOrganizationDefaultTaxCodesRequest = UpdateOrganizationDefaultTaxCodesRequestBody;
+export type UpdateOrganizationDefaultTaxCodesRequest = AcceptDateStrings<UpdateOrganizationDefaultTaxCodesRequestBody>;
 export type UpdateOrganizationDefaultTaxCodesResponse = OrganizationDefaultTaxCodes;
 //# sourceMappingURL=defaults.d.ts.map