@abloatai/ablo 0.36.0 → 0.37.1

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

@@ -1,420 +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;
-    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            date: "date";
-            enum: "enum";
-            json: "json";
-        }>;
-        isOptional: z.ZodBoolean;
-        isIndexed: z.ZodBoolean;
-        column: z.ZodOptional<z.ZodString>;
-        enumValues: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>>>;
-    relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodEnum<{
-            belongsTo: "belongsTo";
-            hasMany: "hasMany";
-            hasOne: "hasOne";
-        }>;
-        target: z.ZodString;
-        foreignKey: z.ZodString;
-    }, z.core.$strip>>>;
-}, 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;
-        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                date: "date";
-                enum: "enum";
-                json: "json";
-            }>;
-            isOptional: z.ZodBoolean;
-            isIndexed: z.ZodBoolean;
-            column: z.ZodOptional<z.ZodString>;
-            enumValues: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-        }, z.core.$strip>>>;
-        relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                belongsTo: "belongsTo";
-                hasMany: "hasMany";
-                hasOne: "hasOne";
-            }>;
-            target: z.ZodString;
-            foreignKey: z.ZodString;
-        }, z.core.$strip>>>;
-    }, 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;
-        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                date: "date";
-                enum: "enum";
-                json: "json";
-            }>;
-            isOptional: z.ZodBoolean;
-            isIndexed: z.ZodBoolean;
-            column: z.ZodOptional<z.ZodString>;
-            enumValues: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-        }, z.core.$strip>>>;
-        relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                belongsTo: "belongsTo";
-                hasMany: "hasMany";
-                hasOne: "hasOne";
-            }>;
-            target: z.ZodString;
-            foreignKey: z.ZodString;
-        }, z.core.$strip>>>;
-    }, 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>;