@abloatai/ablo 0.35.0 → 0.37.0

package/dist/transaction/wire/accountResponses.d.ts

@@ -1,351 +0,0 @@
-/**
- * What the ACCOUNT routes answer with — the surface you reach through the
- * `ablo` CLI rather than through a model: `GET /v1/projects`, `GET /api/schema`,
- * `GET /v1/logs`, `GET /v1/usage`.
- *
- * These are the shapes the server, the CLI, and the MCP server all have to
- * agree on. Before this module each of them spelled the shape out again — the
- * server inline in `c.json({ … })`, the others in hand-written interfaces — so
- * a renamed field broke a consumer at runtime with nothing failing in between.
- *
- * None of these endpoints appear in the published OpenAPI contract yet (they
- * sit in the spec test's `NOT_YET_PUBLISHED` set). Deriving the spec from these
- * schemas is what removes them from it.
- */
-import { z } from 'zod';
-import type { SyncDeltaAction } from './delta.js';
-/**
- * One project — an app's own schema, data planes, and keys. `default` marks the
- * organization's implicit project, whose id is the organization's own.
- */
-export declare const projectResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"project">;
-    id: z.ZodString;
-    slug: z.ZodString;
-    name: z.ZodString;
-    default: z.ZodBoolean;
-    created_at: z.ZodString;
-}, z.core.$strip>;
-export type ProjectResponse = z.infer<typeof projectResponseSchema>;
-/**
- * `GET /v1/projects`.
- *
- * Note what this is NOT: the canonical {@link ListEnvelope}. An org's projects
- * are returned whole, so the route emits `data` with no `has_more`/`next_cursor`
- * beside it. That divergence is real and this schema states it rather than
- * describing a pagination the endpoint does not implement — adding the two
- * fields is an API change, not a documentation fix.
- */
-export declare const projectListResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        object: z.ZodLiteral<"project">;
-        id: z.ZodString;
-        slug: z.ZodString;
-        name: z.ZodString;
-        default: z.ZodBoolean;
-        created_at: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type ProjectListResponse = z.infer<typeof projectListResponseSchema>;
-/** One minted key, returned exactly once — the plaintext is never readable again. */
-export declare const provisionedKeySchema: z.ZodObject<{
-    apiKey: z.ZodString;
-    expiresAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ProvisionedKey = z.infer<typeof provisionedKeySchema>;
-/**
- * What the CLI device flow gets back once a browser approval is exchanged for
- * credentials: the sandbox key `ablo push` authors with, and the restricted
- * production key that only observes.
- *
- * `project` is the project both keys are scoped to, resolved SERVER-SIDE from
- * the requested slug — null means the organization's default. The server's
- * answer is authoritative because it is what resolved the slug to an id, so the
- * CLI stores keys under the project named here rather than the one it asked
- * for.
- */
-export declare const provisionKeyResponseSchema: z.ZodObject<{
-    test: z.ZodObject<{
-        apiKey: z.ZodString;
-        expiresAt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    live: z.ZodOptional<z.ZodObject<{
-        apiKey: z.ZodString;
-        expiresAt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    organizationId: z.ZodOptional<z.ZodString>;
-    organizationSlug: z.ZodOptional<z.ZodString>;
-    project: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        slug: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type ProvisionKeyResponse = z.infer<typeof provisionKeyResponseSchema>;
-/**
- * A model's declared conflict disposition as it travels on the wire, keyed by
- * committer kind.
- *
- * Spelled here rather than imported from the policy layer, which states the same
- * three members as a TypeScript interface: `wire/` holds runtime-validatable
- * schemas, and it is the protocol leaf — everything depends on it and it depends
- * on nothing. The check that the two never drift therefore lives on the policy
- * side of that edge, next to the interface, in `../policy/types.ts`.
- */
-export declare const conflictAxisWireSchema: z.ZodObject<{
-    user: z.ZodOptional<z.ZodEnum<{
-        reject: "reject";
-        overwrite: "overwrite";
-        notify: "notify";
-    }>>;
-    agent: z.ZodOptional<z.ZodEnum<{
-        reject: "reject";
-        overwrite: "overwrite";
-        notify: "notify";
-    }>>;
-    system: z.ZodOptional<z.ZodEnum<{
-        reject: "reject";
-        overwrite: "overwrite";
-        notify: "notify";
-    }>>;
-}, z.core.$strip>;
-/** One model in the deployed schema, as the schema read reports it. */
-export declare const schemaModelResponseSchema: z.ZodObject<{
-    key: z.ZodString;
-    typename: z.ZodString;
-    conflict: z.ZodNullable<z.ZodObject<{
-        user: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-        agent: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-        system: z.ZodOptional<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>;
-    }, z.core.$strip>>;
-    hash: z.ZodString;
-}, z.core.$strip>;
-export type SchemaModelResponse = z.infer<typeof schemaModelResponseSchema>;
-/**
- * `GET /api/schema` — the schema active on the caller's plane.
- *
- * A discriminated union because the two answers carry different fields, and the
- * difference is the one a caller must act on: `active: false` means nothing has
- * been pushed to this plane, so `models` is empty and `ablo push` is the fix.
- * Reporting that as an inactive artifact with absent metadata, rather than as
- * optional fields on one shape, is what stops a consumer from reading a missing
- * `version` as a version of zero.
- */
-export declare const schemaReadResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    active: z.ZodLiteral<false>;
-    environment: z.ZodString;
-    project: z.ZodNullable<z.ZodString>;
-    models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        typename: z.ZodString;
-        conflict: z.ZodNullable<z.ZodObject<{
-            user: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-            agent: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-            system: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-        }, z.core.$strip>>;
-        hash: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>, z.ZodObject<{
-    active: z.ZodLiteral<true>;
-    environment: z.ZodString;
-    project: z.ZodNullable<z.ZodString>;
-    models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        typename: z.ZodString;
-        conflict: z.ZodNullable<z.ZodObject<{
-            user: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-            agent: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-            system: z.ZodOptional<z.ZodEnum<{
-                reject: "reject";
-                overwrite: "overwrite";
-                notify: "notify";
-            }>>;
-        }, z.core.$strip>>;
-        hash: z.ZodString;
-    }, z.core.$strip>>>;
-    schemaId: z.ZodString;
-    version: z.ZodNumber;
-    hash: z.ZodString;
-    pushedAt: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>], "active">;
-export type SchemaReadResponse = z.infer<typeof schemaReadResponseSchema>;
-/**
- * What a log reader calls each kind of entry.
- *
- * The log carries the full delta vocabulary, not just writes, so this has a
- * word for every one of them — a reader should never be shown the stored
- * letter. The eight are the plain-language face of {@link SyncDeltaAction}.
- */
-export declare const logOpSchema: z.ZodEnum<{
-    update: "update";
-    visible: "visible";
-    create: "create";
-    delete: "delete";
-    archive: "archive";
-    revive: "revive";
-    group_added: "group_added";
-    group_removed: "group_removed";
-}>;
-export type LogOp = z.infer<typeof logOpSchema>;
-/**
- * The stored action letter, as a log reader sees it.
- *
- * Typed against {@link SyncDeltaAction} so it is total by construction: adding
- * a ninth action to the vocabulary stops this compiling until it has a word.
- * The alternative — a lookup with a fallback — is what let `A` reach callers
- * as the bare letter "a".
- */
-export declare const LOG_OP_BY_ACTION: Readonly<Record<SyncDeltaAction, LogOp>>;
-/** One entry in the log: what changed, and who changed it. */
-export declare const logEventSchema: z.ZodObject<{
-    object: z.ZodLiteral<"log_event">;
-    id: z.ZodNumber;
-    at: z.ZodString;
-    model: z.ZodString;
-    op: z.ZodEnum<{
-        update: "update";
-        visible: "visible";
-        create: "create";
-        delete: "delete";
-        archive: "archive";
-        revive: "revive";
-        group_added: "group_added";
-        group_removed: "group_removed";
-    }>;
-    recordId: z.ZodString;
-    actor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type LogEvent = z.infer<typeof logEventSchema>;
-/**
- * One day's usage. `results` is one row per `group_by` combination, carrying
- * the requested dimensions plus `total` and `count`; with no `group_by` it is a
- * single ungrouped row. The keys therefore depend on the request, which is why
- * the row stays open rather than claiming a fixed shape.
- *
- * `total` arrives as a string — it is a bigint in the database, and JSON has no
- * lossless number for it.
- */
-export declare const usageBucketSchema: z.ZodObject<{
-    starting_at: z.ZodString;
-    ending_at: z.ZodString;
-    results: z.ZodReadonly<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-}, z.core.$strip>;
-export type UsageBucket = z.infer<typeof usageBucketSchema>;
-/**
- * One of the org's keys, as a management surface may show it.
- *
- * Everything here is safe to display: the prefix identifies a key without being
- * one. There is deliberately no field for the key itself — plaintext exists only
- * in the response to the mint that created it, and the store keeps a SHA-256
- * hash, so no later read can return it.
- */
-export declare const controlKeySchema: z.ZodObject<{
-    id: z.ZodString;
-    keyPrefix: z.ZodString;
-    label: z.ZodNullable<z.ZodString>;
-    kind: z.ZodString;
-    scopes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    createdAt: z.ZodString;
-    lastUsedAt: z.ZodNullable<z.ZodString>;
-    expiresAt: z.ZodNullable<z.ZodString>;
-    projectId: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type ControlKey = z.infer<typeof controlKeySchema>;
-/**
- * `GET /v1/dashboard/keys` — the org's live, hand-managed keys.
- *
- * Like the project list, this is not the canonical {@link ListEnvelope}: it
- * answers with a bare `keys` array. Stated as it is rather than as the envelope
- * it resembles.
- */
-export declare const controlKeyListResponseSchema: z.ZodObject<{
-    keys: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        keyPrefix: z.ZodString;
-        label: z.ZodNullable<z.ZodString>;
-        kind: z.ZodString;
-        scopes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        createdAt: z.ZodString;
-        lastUsedAt: z.ZodNullable<z.ZodString>;
-        expiresAt: z.ZodNullable<z.ZodString>;
-        projectId: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type ControlKeyListResponse = z.infer<typeof controlKeyListResponseSchema>;
-/**
- * `POST /v1/dashboard/keys` — the mint.
- *
- * `plaintext` is the only place the secret ever appears. The store keeps a
- * SHA-256 hash, so nothing can return it again: a consumer that reads the wrong
- * field name here does not get an error, it gets `undefined`, and the key is
- * gone. That is the whole reason this shape is defined once rather than
- * described at each end.
- */
-export declare const keyMintedResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodNullable<z.ZodString>;
-    keyPrefix: z.ZodString;
-    createdAt: z.ZodString;
-    createdBy: z.ZodNullable<z.ZodString>;
-    projectId: z.ZodNullable<z.ZodString>;
-    plaintext: z.ZodString;
-}, z.core.$strip>;
-export type KeyMintedResponse = z.infer<typeof keyMintedResponseSchema>;
-/**
- * `DELETE /v1/dashboard/keys/:id`. `activeSessionsClosed` reports how many live
- * connections the revocation cut, so a caller can see it took effect on sessions
- * already open rather than only on future ones. A second revoke of the same key
- * is not an error — it answers `alreadyRevoked` and closes nothing.
- */
-export declare const keyRevokedResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    revoked: z.ZodLiteral<true>;
-    revokedAt: z.ZodOptional<z.ZodString>;
-    alreadyRevoked: z.ZodOptional<z.ZodBoolean>;
-    activeSessionsClosed: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type KeyRevokedResponse = z.infer<typeof keyRevokedResponseSchema>;
-/** `GET /v1/usage` — daily buckets, shaped after a usage report. */
-export declare const usageReportResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"usage_report">;
-    buckets: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        starting_at: z.ZodString;
-        ending_at: z.ZodString;
-        results: z.ZodReadonly<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>>;
-    has_more: z.ZodBoolean;
-    data_freshness_seconds: z.ZodNumber;
-}, z.core.$strip>;
-export type UsageReportResponse = z.infer<typeof usageReportResponseSchema>;

package/dist/transaction/wire/accountResponses.js

@@ -1,255 +0,0 @@
-/**
- * What the ACCOUNT routes answer with — the surface you reach through the
- * `ablo` CLI rather than through a model: `GET /v1/projects`, `GET /api/schema`,
- * `GET /v1/logs`, `GET /v1/usage`.
- *
- * These are the shapes the server, the CLI, and the MCP server all have to
- * agree on. Before this module each of them spelled the shape out again — the
- * server inline in `c.json({ … })`, the others in hand-written interfaces — so
- * a renamed field broke a consumer at runtime with nothing failing in between.
- *
- * None of these endpoints appear in the published OpenAPI contract yet (they
- * sit in the spec test's `NOT_YET_PUBLISHED` set). Deriving the spec from these
- * schemas is what removes them from it.
- */
-import { z } from 'zod';
-import { onStaleModeSchema } from '../coordination/schema.js';
-/**
- * One project — an app's own schema, data planes, and keys. `default` marks the
- * organization's implicit project, whose id is the organization's own.
- */
-export const projectResponseSchema = z.object({
-    object: z.literal('project'),
-    id: z.string(),
-    slug: z.string(),
-    name: z.string(),
-    default: z.boolean(),
-    created_at: z.string(),
-});
-/**
- * `GET /v1/projects`.
- *
- * Note what this is NOT: the canonical {@link ListEnvelope}. An org's projects
- * are returned whole, so the route emits `data` with no `has_more`/`next_cursor`
- * beside it. That divergence is real and this schema states it rather than
- * describing a pagination the endpoint does not implement — adding the two
- * fields is an API change, not a documentation fix.
- */
-export const projectListResponseSchema = z.object({
-    object: z.literal('list'),
-    data: z.array(projectResponseSchema).readonly(),
-});
-/** One minted key, returned exactly once — the plaintext is never readable again. */
-export const provisionedKeySchema = z.object({
-    apiKey: z.string(),
-    expiresAt: z.string().optional(),
-});
-/**
- * What the CLI device flow gets back once a browser approval is exchanged for
- * credentials: the sandbox key `ablo push` authors with, and the restricted
- * production key that only observes.
- *
- * `project` is the project both keys are scoped to, resolved SERVER-SIDE from
- * the requested slug — null means the organization's default. The server's
- * answer is authoritative because it is what resolved the slug to an id, so the
- * CLI stores keys under the project named here rather than the one it asked
- * for.
- */
-export const provisionKeyResponseSchema = z.object({
-    test: provisionedKeySchema,
-    live: provisionedKeySchema.optional(),
-    organizationId: z.string().optional(),
-    organizationSlug: z.string().optional(),
-    project: z.object({ id: z.string(), slug: z.string() }).nullable().optional(),
-});
-/**
- * A model's declared conflict disposition as it travels on the wire, keyed by
- * committer kind.
- *
- * Spelled here rather than imported from the policy layer, which states the same
- * three members as a TypeScript interface: `wire/` holds runtime-validatable
- * schemas, and it is the protocol leaf — everything depends on it and it depends
- * on nothing. The check that the two never drift therefore lives on the policy
- * side of that edge, next to the interface, in `../policy/types.ts`.
- */
-export const conflictAxisWireSchema = z.object({
-    user: onStaleModeSchema.optional(),
-    agent: onStaleModeSchema.optional(),
-    system: onStaleModeSchema.optional(),
-});
-/** One model in the deployed schema, as the schema read reports it. */
-export const schemaModelResponseSchema = z.object({
-    /** The key local code addresses (`ablo.documents`). */
-    key: z.string(),
-    /** The wire typename the engine routes and gates on. */
-    typename: z.string(),
-    /** Declared disposition, or null for the engine default. */
-    conflict: conflictAxisWireSchema.nullable(),
-    /** Per-model content hash — the unit of the client's drift check. */
-    hash: z.string(),
-});
-/**
- * `GET /api/schema` — the schema active on the caller's plane.
- *
- * A discriminated union because the two answers carry different fields, and the
- * difference is the one a caller must act on: `active: false` means nothing has
- * been pushed to this plane, so `models` is empty and `ablo push` is the fix.
- * Reporting that as an inactive artifact with absent metadata, rather than as
- * optional fields on one shape, is what stops a consumer from reading a missing
- * `version` as a version of zero.
- */
-export const schemaReadResponseSchema = z.discriminatedUnion('active', [
-    z.object({
-        active: z.literal(false),
-        environment: z.string(),
-        project: z.string().nullable(),
-        models: z.array(schemaModelResponseSchema).readonly(),
-    }),
-    z.object({
-        active: z.literal(true),
-        environment: z.string(),
-        project: z.string().nullable(),
-        models: z.array(schemaModelResponseSchema).readonly(),
-        schemaId: z.string(),
-        version: z.number(),
-        hash: z.string(),
-        pushedAt: z.string().nullable(),
-    }),
-]);
-/**
- * What a log reader calls each kind of entry.
- *
- * The log carries the full delta vocabulary, not just writes, so this has a
- * word for every one of them — a reader should never be shown the stored
- * letter. The eight are the plain-language face of {@link SyncDeltaAction}.
- */
-export const logOpSchema = z.enum([
-    'create',
-    'update',
-    'delete',
-    'archive',
-    'revive',
-    'visible',
-    'group_added',
-    'group_removed',
-]);
-/**
- * The stored action letter, as a log reader sees it.
- *
- * Typed against {@link SyncDeltaAction} so it is total by construction: adding
- * a ninth action to the vocabulary stops this compiling until it has a word.
- * The alternative — a lookup with a fallback — is what let `A` reach callers
- * as the bare letter "a".
- */
-export const LOG_OP_BY_ACTION = {
-    I: 'create',
-    U: 'update',
-    D: 'delete',
-    A: 'archive',
-    V: 'revive',
-    C: 'visible',
-    G: 'group_added',
-    S: 'group_removed',
-};
-/** One entry in the log: what changed, and who changed it. */
-export const logEventSchema = z.object({
-    /**
-     * Which arm of the feed this is. `GET /v1/logs` can carry claim transitions
-     * alongside commits, and the two are told apart by this tag rather than by
-     * sniffing for `op` versus `status` — a discriminator a consumer has to infer
-     * is one every consumer infers differently.
-     */
-    object: z.literal('log_event'),
-    id: z.number(),
-    at: z.string(),
-    model: z.string(),
-    op: logOpSchema,
-    recordId: z.string(),
-    /** `kind:id` of the committer, or null when the log recorded none. */
-    actor: z.string().nullable(),
-});
-/**
- * One day's usage. `results` is one row per `group_by` combination, carrying
- * the requested dimensions plus `total` and `count`; with no `group_by` it is a
- * single ungrouped row. The keys therefore depend on the request, which is why
- * the row stays open rather than claiming a fixed shape.
- *
- * `total` arrives as a string — it is a bigint in the database, and JSON has no
- * lossless number for it.
- */
-export const usageBucketSchema = z.object({
-    starting_at: z.string(),
-    ending_at: z.string(),
-    results: z.array(z.record(z.string(), z.unknown())).readonly(),
-});
-/**
- * One of the org's keys, as a management surface may show it.
- *
- * Everything here is safe to display: the prefix identifies a key without being
- * one. There is deliberately no field for the key itself — plaintext exists only
- * in the response to the mint that created it, and the store keeps a SHA-256
- * hash, so no later read can return it.
- */
-export const controlKeySchema = z.object({
-    id: z.string(),
-    /** The leading, non-secret segment — enough to recognise a key by. */
-    keyPrefix: z.string(),
-    label: z.string().nullable(),
-    kind: z.string(),
-    scopes: z.array(z.string()).readonly(),
-    createdAt: z.string(),
-    lastUsedAt: z.string().nullable(),
-    expiresAt: z.string().nullable(),
-    /** The project this key is scoped to; null = the org-default project. */
-    projectId: z.string().nullable(),
-});
-/**
- * `GET /v1/dashboard/keys` — the org's live, hand-managed keys.
- *
- * Like the project list, this is not the canonical {@link ListEnvelope}: it
- * answers with a bare `keys` array. Stated as it is rather than as the envelope
- * it resembles.
- */
-export const controlKeyListResponseSchema = z.object({
-    keys: z.array(controlKeySchema).readonly(),
-});
-/**
- * `POST /v1/dashboard/keys` — the mint.
- *
- * `plaintext` is the only place the secret ever appears. The store keeps a
- * SHA-256 hash, so nothing can return it again: a consumer that reads the wrong
- * field name here does not get an error, it gets `undefined`, and the key is
- * gone. That is the whole reason this shape is defined once rather than
- * described at each end.
- */
-export const keyMintedResponseSchema = z.object({
-    id: z.string(),
-    label: z.string().nullable(),
-    keyPrefix: z.string(),
-    createdAt: z.string(),
-    createdBy: z.string().nullable(),
-    projectId: z.string().nullable(),
-    /** The secret, in the only response that will ever carry it. */
-    plaintext: z.string(),
-});
-/**
- * `DELETE /v1/dashboard/keys/:id`. `activeSessionsClosed` reports how many live
- * connections the revocation cut, so a caller can see it took effect on sessions
- * already open rather than only on future ones. A second revoke of the same key
- * is not an error — it answers `alreadyRevoked` and closes nothing.
- */
-export const keyRevokedResponseSchema = z.object({
-    id: z.string(),
-    revoked: z.literal(true),
-    revokedAt: z.string().optional(),
-    alreadyRevoked: z.boolean().optional(),
-    activeSessionsClosed: z.number().optional(),
-});
-/** `GET /v1/usage` — daily buckets, shaped after a usage report. */
-export const usageReportResponseSchema = z.object({
-    object: z.literal('usage_report'),
-    buckets: z.array(usageBucketSchema).readonly(),
-    has_more: z.boolean(),
-    /** How stale the rollup behind these numbers may be. */
-    data_freshness_seconds: z.number(),
-});

package/dist/transaction/wire/auth.d.ts

@@ -1,49 +0,0 @@
-/**
- * The request body for minting a session credential.
- *
- * `POST /v1/ephemeral_keys` is the first call any caller makes — nothing else in
- * the API is reachable without the credential it returns. That makes it the one
- * route a published contract cannot omit, so its shape lives here beside the
- * rest of the boundary rather than being read field-by-field out of the handler.
- *
- * The response side already had a home: `EphemeralKeyResponseSchema` in
- * `auth/schemas.ts`.
- */
-import { z } from 'zod';
-/** The participant this session acts as. */
-export declare const ephemeralKeyUserSchema: z.ZodObject<{
-    id: z.ZodString;
-    teamIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type EphemeralKeyUser = z.infer<typeof ephemeralKeyUserSchema>;
-/**
- * `POST /v1/ephemeral_keys` — mint a short-lived session credential.
- *
- * Only a secret key (`sk_`) may call this: a session cannot mint itself. By
- * default the key mints into the caller's own organization; naming a different
- * `organizationId` is the multi-tenant case and requires the
- * `ephemeral:mint-any-org` scope, which is the same privilege that allows
- * binding the session's schema to another organization's project.
- */
-export declare const ephemeralKeyRequestSchema: z.ZodObject<{
-    user: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        teamIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    userId: z.ZodOptional<z.ZodString>;
-    organizationId: z.ZodOptional<z.ZodString>;
-    schemaProjectId: z.ZodOptional<z.ZodString>;
-    schemaOwnerOrgId: z.ZodOptional<z.ZodString>;
-    syncGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    ttlSeconds: z.ZodOptional<z.ZodNumber>;
-    label: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type EphemeralKeyRequest = z.infer<typeof ephemeralKeyRequestSchema>;
-/**
- * The capability mint body lives with the rest of the capability vocabulary in
- * `auth/capability.ts` — the grant is one structure, and its request form is a
- * face of it rather than a separate shape. Re-exported here so the wire barrel
- * stays the single import path for the boundary.
- */
-export { capabilityRequestSchema, grantedOperationSchema, capabilityOperationSchema, } from '../auth/capability.js';
-export type { CapabilityRequest, GrantedOperation, CapabilityOperation, } from '../auth/capability.js';