import { z } from "zod";
import { VendoError, type VendoErrorCode } from "./errors.js";
/** Store design v1 — the wire protocol version tag. The HTTP profile of the
    StoreOps contract, shared verbatim by the cloud client and the BYO
    `httpStore` template. */
export declare const VENDO_STORE_WIRE_FORMAT: "vendo/store-wire@1";
/** Mount-relative endpoint paths. POST-JSON RPC for all mutations and queries;
    GET /status doubles as the discovery handshake.
    ONE Idempotency-Key header on every mutation.
    ONE keyset cursor (default 100, max 1000) on every list op.
    Unknown op → enveloped `not-implemented` (501). */
export declare const STORE_WIRE_PATHS: {
    readonly "engine.get": "/engine/get";
    readonly "engine.put": "/engine/put";
    readonly "engine.delete": "/engine/delete";
    readonly "engine.list": "/engine/list";
    readonly "engine.claim": "/engine/claim";
    readonly "engine.insertIfAbsent": "/engine/insertIfAbsent";
    readonly "engine.compareAndSwap": "/engine/compareAndSwap";
    readonly "blobs.put": "/blobs/put";
    readonly "blobs.get": "/blobs/get";
    readonly "blobs.delete": "/blobs/delete";
    readonly "blobs.list": "/blobs/list";
    readonly "appData.put": "/app-data/put";
    readonly "appData.get": "/app-data/get";
    readonly "appData.list": "/app-data/list";
    readonly "appData.delete": "/app-data/delete";
    readonly "appData.putFile": "/app-data/putFile";
    readonly "appData.getFile": "/app-data/getFile";
    readonly "appData.listFiles": "/app-data/listFiles";
    readonly "appData.deleteFile": "/app-data/deleteFile";
    readonly "transcripts.putThread": "/transcripts/putThread";
    readonly "transcripts.getThread": "/transcripts/getThread";
    readonly "transcripts.listThreads": "/transcripts/listThreads";
    readonly "transcripts.deleteThread": "/transcripts/deleteThread";
    readonly "transcripts.putMessage": "/transcripts/putMessage";
    readonly "transcripts.appendMessages": "/transcripts/appendMessages";
    readonly "transcripts.recordAnswer": "/transcripts/recordAnswer";
    readonly "harness.get": "/harness/get";
    readonly "harness.set": "/harness/set";
    readonly "harness.clear": "/harness/clear";
    readonly "workspace.index": "/workspace/index";
    readonly "workspace.read": "/workspace/read";
    readonly "workspace.commit": "/workspace/commit";
    readonly "workspace.history": "/workspace/history";
    readonly "lifecycle.erase": "/erase";
    readonly "lifecycle.promote": "/lifecycle/promote";
    readonly "audit.list": "/audit/list";
    readonly "secrets.get": "/secrets/get";
    readonly "secrets.set": "/secrets/set";
    readonly "secrets.list": "/secrets/list";
    readonly "secrets.delete": "/secrets/delete";
    readonly footprint: "/footprint";
    readonly "retention.quarantine": "/retention/quarantine";
    readonly "retention.purge": "/retention/purge";
    readonly status: "/status";
    readonly "audit.tally": "/audit/tally";
    readonly "usage.record": "/usage/record";
    readonly "usage.count": "/usage/count";
    readonly "usage.tally": "/usage/tally";
    readonly "turn.load": "/turn/load";
    readonly "turn.commit": "/turn/commit";
};
/** The op name a client sends and a mount serves, as the manifest spells it. */
export type StoreWireOp = keyof typeof STORE_WIRE_PATHS;
/** {@link STORE_WIRE_MUTATES} for an op name off the wire, where the name is a
    string a caller chose. An op this table has never heard of is not a
    mutation — the mount answers it with the wire's own 501 either way. */
export declare const isStoreWireMutation: (op: string) => boolean;
export declare const storeWireCollectionGetRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    id: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionPutRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionDeleteRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    id: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** The forward-walk bound. `after` is an opaque string, NOT a datetime: it is
    echoed back verbatim from a previous page, and validating it as a datetime
    here would quietly re-encode a value whose extra precision is the whole
    point (see `Watermark` in store.ts). */
export declare const storeWireWatermarkSchema: z.ZodObject<{
    field: z.ZodString;
    after: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    field: z.ZodString;
    after: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    field: z.ZodString;
    after: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** `engine.list`'s query. A watermark pages oldest-first from its bound and a
    cursor pages newest-first from its own; a body carrying both is asking for
    two different walks at once and is refused here rather than resolved by a
    precedence rule nobody could guess. */
export declare const engineListQuerySchema: z.ZodEffects<z.ZodObject<{
    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
} & {
    watermark: z.ZodOptional<z.ZodObject<{
        field: z.ZodString;
        after: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
} & {
    watermark: z.ZodOptional<z.ZodObject<{
        field: z.ZodString;
        after: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
} & {
    watermark: z.ZodOptional<z.ZodObject<{
        field: z.ZodString;
        after: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
} & {
    watermark: z.ZodOptional<z.ZodObject<{
        field: z.ZodString;
        after: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limit: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
} & {
    watermark: z.ZodOptional<z.ZodObject<{
        field: z.ZodString;
        after: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        field: z.ZodString;
        after: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionListRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    query: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    query: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    query: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limit: z.ZodOptional<z.ZodNumber>;
        cursor: z.ZodOptional<z.ZodString>;
    } & {
        watermark: z.ZodOptional<z.ZodObject<{
            field: z.ZodString;
            after: z.ZodString;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            field: z.ZodString;
            after: z.ZodString;
        }, z.ZodTypeAny, "passthrough">>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionClaimRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    expected: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    replacement: z.ZodOptional<z.ZodObject<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    expected: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    replacement: z.ZodOptional<z.ZodObject<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    expected: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    replacement: z.ZodOptional<z.ZodObject<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionInsertIfAbsentRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireCollectionCompareAndSwapRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    expectedRevision: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    expectedRevision: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    record: z.ZodObject<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodUnknown;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.ZodTypeAny, "passthrough">>;
    expectedRevision: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** Blob bytes are base64-encoded on the wire. `bytes` carries no `.min(1)`:
    base64 of a ZERO-BYTE payload is the empty string, and an empty file is
    content — an empty upload, a truncated log, a placeholder an app wrote.
    Refusing it here made the one thing a store must never do (lose a
    successful write) into the client's default: the put failed, and the
    caller's `get` then answered null exactly as it would for a key nobody had
    ever written. Both local implementations always accepted it; this line is
    where the wire stopped disagreeing with them. */
export declare const storeWireBlobsPutRequestSchema: z.ZodObject<{
    namespace: z.ZodString;
    key: z.ZodString;
    bytes: z.ZodString;
    contentType: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    namespace: z.ZodString;
    key: z.ZodString;
    bytes: z.ZodString;
    contentType: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    namespace: z.ZodString;
    key: z.ZodString;
    bytes: z.ZodString;
    contentType: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireBlobsGetRequestSchema: z.ZodObject<{
    namespace: z.ZodString;
    key: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    namespace: z.ZodString;
    key: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    namespace: z.ZodString;
    key: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireBlobsDeleteRequestSchema: z.ZodObject<{
    namespace: z.ZodString;
    key: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    namespace: z.ZodString;
    key: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    namespace: z.ZodString;
    key: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireBlobsListRequestSchema: z.ZodObject<{
    namespace: z.ZodString;
    prefix: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    namespace: z.ZodString;
    prefix: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    namespace: z.ZodString;
    prefix: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTranscriptsPutThreadRequestSchema: z.ZodObject<{
    thread: z.ZodObject<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    thread: z.ZodObject<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    thread: z.ZodObject<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
/** An id, and nothing else. `getThread` answers with ONE record and the wire's
    read answer has no field a next-page cursor could ride, so the `cursor` and
    `limit` this schema used to declare were a windowing request no mount could
    complete — the client sent them, every implementation ignored them, and the
    caller got the whole transcript back with no way to tell. Retired rather
    than implemented: paging a transcript needs an answer shaped to say "there
    is more", which is a different op. `.passthrough()` means a client that
    still sends them is read, not refused. */
export declare const storeWireTranscriptsGetThreadRequestSchema: z.ZodObject<{
    id: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTranscriptsListThreadsRequestSchema: z.ZodObject<{
    subject: z.ZodOptional<z.ZodString>;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    subject: z.ZodOptional<z.ZodString>;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    subject: z.ZodOptional<z.ZodString>;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTranscriptsDeleteThreadRequestSchema: z.ZodObject<{
    id: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    id: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTranscriptsPutMessageRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    message: z.ZodUnknown;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    message: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    message: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">>;
/** Append a batch of messages to a thread the CALLER names the owner of, so the
    service can enforce ownership in its own statement instead of handing the
    client a whole thread to check first. The answer is `{revision, count}` and
    deliberately NOT the thread: returning it would put the entire conversation
    back on the wire on every turn, which is the cost this op exists to remove. */
export declare const storeWireTranscriptsAppendMessagesRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    subject: z.ZodString;
    messages: z.ZodArray<z.ZodUnknown, "many">;
    title: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
    messages: z.ZodArray<z.ZodUnknown, "many">;
    title: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
    messages: z.ZodArray<z.ZodUnknown, "many">;
    title: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export interface StoreWireAppendMessagesResult {
    revision: string;
    count: number;
}
/** The op count a mount must report on `/status` before a client may send
    `transcripts.appendMessages` — the 36th op, and the first one a shipped
    client has to feature-detect. The wire has no capability list and needs
    none: `/status` is already the discovery handshake, and the count is its
    only signal. Compared with `>=`, and FROZEN at the count this op shipped
    with — `===` would refuse the op the day a 37th is added, pinning every
    client on the slow path forever with nothing to see; and
    `Object.keys(STORE_WIRE_PATHS).length` would do the same from the client's
    side.

    ⚠ ADDING OP 37? READ THIS. The count is a PROXY for capability, and it
    holds only while ops are ONLY EVER ADDED. Remove one while adding another
    and the count still reaches 36 on a mount that no longer serves this op —
    the client then believes it is supported, sends it, and takes the loud 501
    this whole mechanism exists to avoid. That is not hypothetical: console
    #468 ("restore the `records.*` store wire deleted by #456") is a production
    incident from exactly that shape. Deleting a wire op means retiring this
    constant, not renumbering it.

    Detect once, cache, and route to the older getThread + putMessage path when
    the mount is behind — never send it blind and read the 501 as a fallback
    signal (#1251: a failed mutation is not a capability answer).

    ⚠ AND A SECOND CONSTANT OF THIS KIND MUST CLEAR THE BAR BELOW — only
    STORE_WIRE_TURN_OPS ever has. Ops 37-48 (audit, secrets, footprint,
    retention, the audit tally, usage) added no twin, and most ops should not.
    A pre-send check earns its keep only when sending blind is
    unsafe, and that is true of exactly one shape: a MUTATION with a cheaper
    fallback, where a 501 leaves the caller unable to tell "never ran" from
    "ran and failed". Every one of 37-45 is a new PATH, so an older mount
    refuses it with the enveloped 501 this protocol already answers unknown ops
    with — loud, specific, and impossible to mistake for data. The one
    genuinely invisible addition, the watermark bound on `engine.list`, is a
    FIELD on an existing op that `.passthrough()` would let an old mount ignore
    in silence; it is detected by the echo on its own answer
    (`EngineListPage.watermark`), not from here. */
export declare const STORE_WIRE_APPEND_MESSAGES_OPS = 36;
export declare const storeWireTranscriptsRecordAnswerRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    answer: z.ZodUnknown;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    answer: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    answer: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">>;
/** The slot is a THREAD's, and says so. It rode a synthetic `appId`
    (`harness_state:<threadId>`) while the state lived in `vendo_state`, whose key
    was (app_id, subject); it now lives on the thread row itself, so the key names
    the thread.

    The rename is a BREAKING wire change, and it is a loud one in both
    directions: `threadId` is required, so an old client's `{appId, subject}` body
    fails this schema, and a new client's `{threadId, subject}` fails an old
    mount's — each side answers an enveloped `validation` (400) rather than
    reading the other's body as a slot it can serve. There is nothing to
    feature-detect here: `/status`'s `ops` level is a monotone count that only
    ever grows (STORE_WIRE_PATHS' header), and no op is added or removed, so the
    level cannot express this and must not try. */
export declare const storeWireHarnessGetRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireHarnessSetRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    subject: z.ZodString;
    state: z.ZodUnknown;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
    state: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
    state: z.ZodUnknown;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireHarnessClearRequestSchema: z.ZodObject<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    threadId: z.ZodString;
    subject: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** One committed change to one path: new content, or a tombstone that removes
    it (deletion was otherwise inexpressible over the wire). `expectedRevision`
    makes the write a strict compare-and-swap against the revision the caller
    read — the `/orgs` mounts' policy — and a stale one refuses the commit.
    It has THREE states: a number compares, `null` is the create-only guard
    ("the caller read nothing here, so this path must not exist yet"), and the
    absent field is unguarded. Without `null` a caller who checked out before
    the file existed had no way to say so, and the guard degraded into an
    unguarded write that silently overwrote whoever created it first.
    `data` stays unknown: content is the caller's JSON, with binary riding the
    `{"$vendoWorkspaceBytes": base64}` envelope. */
export declare const storeWireWorkspaceEntrySchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodUnknown;
    delete: z.ZodOptional<z.ZodLiteral<true>>;
    expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    path: z.ZodString;
    data: z.ZodUnknown;
    delete: z.ZodOptional<z.ZodLiteral<true>>;
    expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    path: z.ZodString;
    data: z.ZodUnknown;
    delete: z.ZodOptional<z.ZodLiteral<true>>;
    expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireWorkspaceIndexRequestSchema: z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    owner: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireWorkspaceReadRequestSchema: z.ZodObject<{
    paths: z.ZodArray<z.ZodString, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    paths: z.ZodArray<z.ZodString, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    paths: z.ZodArray<z.ZodString, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireWorkspaceCommitRequestSchema: z.ZodObject<{
    entries: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    entries: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    entries: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        path: z.ZodString;
        data: z.ZodUnknown;
        delete: z.ZodOptional<z.ZodLiteral<true>>;
        expectedRevision: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.ZodTypeAny, "passthrough">>, "many">;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/** `path` narrows the page to the commits that touched it (newest first, same
    keyset cursor); without it the page is the whole commit ledger. */
export declare const storeWireWorkspaceHistoryRequestSchema: z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    path: z.ZodOptional<z.ZodString>;
    owner: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    path: z.ZodOptional<z.ZodString>;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    path: z.ZodOptional<z.ZodString>;
    owner: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/** The scope rides the body FLAT, the way the shipped door reads it — no
    `target` wrapper. Exactly ONE of subject/appId: an erase with no scope (or
    an ambiguous both-set scope) is a destructive call with no target and must
    be rejected. */
export declare const storeWireLifecycleEraseRequestSchema: z.ZodEffects<z.ZodObject<{
    subject: z.ZodOptional<z.ZodString>;
    appId: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    subject: z.ZodOptional<z.ZodString>;
    appId: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    subject: z.ZodOptional<z.ZodString>;
    appId: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    subject: z.ZodOptional<z.ZodString>;
    appId: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    subject: z.ZodOptional<z.ZodString>;
    appId: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireLifecyclePromoteRequestSchema: z.ZodObject<{
    appId: z.ZodString;
    orgId: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    appId: z.ZodString;
    orgId: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    appId: z.ZodString;
    orgId: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** An empty body is the whole feed, newest first. */
export declare const storeWireAuditListRequestSchema: z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
} & {
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, z.ZodTypeAny, "passthrough">>;
/** The tally's body: the same four filters, and `from` INSTEAD of a page.
    A real datetime (like retention's cutoffs, unlike a watermark's opaque
    echo): it is a window the caller authored, not a value it read back. Not
    optional — a tally has no cursor, so this floor is the only thing bounding
    the answer, and a body without one asks a mount to group an append-only
    drawer's whole history. */
export declare const storeWireAuditTallyRequestSchema: z.ZodObject<{
    from: z.ZodString;
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    from: z.ZodString;
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    from: z.ZodString;
    kind: z.ZodOptional<z.ZodEnum<["tool-call", "approval", "policy-decision", "run", "app-lifecycle", "share", "door-auth", "principal"]>>;
    venue: z.ZodOptional<z.ZodEnum<["chat", "app", "automation", "mcp"]>>;
    outcome: z.ZodOptional<z.ZodEnum<["ok", "error", "pending-approval", "blocked", "connect-required"]>>;
    decidedBy: z.ZodOptional<z.ZodEnum<["grant", "rule", "judge", "default", "confirmEach", "breaker", "denied", "org", "frozen"]>>;
}, z.ZodTypeAny, "passthrough">>;
/** One metered action, as it happened. `at` is a real datetime the caller
    authored, and `poolKeys` are the shared buckets this action ALSO drew down,
    sent WITH the write rather than looked up at read time: a member who leaves
    a team must not retroactively drain its quota. */
export declare const storeWireUsageRecordRequestSchema: z.ZodObject<{
    subject: z.ZodString;
    action: z.ZodEnum<["message", "generation"]>;
    at: z.ZodString;
    poolKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    subject: z.ZodString;
    action: z.ZodEnum<["message", "generation"]>;
    at: z.ZodString;
    poolKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    subject: z.ZodString;
    action: z.ZodEnum<["message", "generation"]>;
    at: z.ZodString;
    poolKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, z.ZodTypeAny, "passthrough">>;
/** Exactly ONE of subject/poolKey (`lifecycle.erase`'s rule): a count is either
    a person's or a pool's, and a body carrying both — or neither — asks for two
    numbers under one name. `since` is required and inclusive for
    `audit.tally`'s reason: it is the only bound on a drawer that only grows. */
export declare const storeWireUsageCountRequestSchema: z.ZodEffects<z.ZodObject<{
    action: z.ZodEnum<["message", "generation"]>;
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    subject: z.ZodOptional<z.ZodString>;
    poolKey: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    action: z.ZodEnum<["message", "generation"]>;
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    subject: z.ZodOptional<z.ZodString>;
    poolKey: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    action: z.ZodEnum<["message", "generation"]>;
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    subject: z.ZodOptional<z.ZodString>;
    poolKey: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    action: z.ZodEnum<["message", "generation"]>;
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    subject: z.ZodOptional<z.ZodString>;
    poolKey: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    action: z.ZodEnum<["message", "generation"]>;
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    subject: z.ZodOptional<z.ZodString>;
    poolKey: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/** The same window counted per subject instead of for one. Both narrowings are
    optional here precisely because the answer names both. */
export declare const storeWireUsageTallyRequestSchema: z.ZodObject<{
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    action: z.ZodOptional<z.ZodEnum<["message", "generation"]>>;
    subject: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    action: z.ZodOptional<z.ZodEnum<["message", "generation"]>>;
    subject: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    since: z.ZodString;
    until: z.ZodOptional<z.ZodString>;
    action: z.ZodOptional<z.ZodEnum<["message", "generation"]>>;
    subject: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireSecretsGetRequestSchema: z.ZodObject<{
    name: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireSecretsSetRequestSchema: z.ZodObject<{
    name: z.ZodString;
    value: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
    value: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
    value: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** No filter and no page: a vault small enough to need one is not a vault. */
export declare const storeWireSecretsListRequestSchema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireSecretsDeleteRequestSchema: z.ZodObject<{
    name: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** No arguments: the answer is the whole store, and a caller that wants one
    collection reads one entry out of it. */
export declare const storeWireFootprintRequestSchema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
/** Rows older than the cutoff leave the live collection. The cutoff is a real
    datetime here (unlike a watermark, which is an opaque echo): it is a policy
    the caller authored, not a value it read back. */
export declare const storeWireRetentionQuarantineRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    olderThan: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    olderThan: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    olderThan: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
/** The cutoff is on the QUARANTINE time, not the row's age — this verb destroys
    rows, and the recovery grace it honors is measured from when they were
    lifted. */
export declare const storeWireRetentionPurgeRequestSchema: z.ZodObject<{
    collection: z.ZodString;
    quarantinedBefore: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    collection: z.ZodString;
    quarantinedBefore: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    collection: z.ZodString;
    quarantinedBefore: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTurnLoadRequestSchema: z.ZodObject<{
    thread: z.ZodObject<{
        id: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
    index: z.ZodObject<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodObject<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
    usage: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    thread: z.ZodObject<{
        id: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
    index: z.ZodObject<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodObject<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
    usage: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    thread: z.ZodObject<{
        id: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
    index: z.ZodObject<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        cursor: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    } & {
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodObject<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        paths: z.ZodArray<z.ZodString, "many">;
        owner: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>>;
    usage: z.ZodOptional<z.ZodEffects<z.ZodObject<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        action: z.ZodEnum<["message", "generation"]>;
        since: z.ZodString;
        until: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        poolKey: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTurnLoadResponseSchema: z.ZodObject<{
    thread: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    index: z.ZodObject<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    harness: z.ZodOptional<z.ZodUnknown>;
    usage: z.ZodOptional<z.ZodNumber>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    thread: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    index: z.ZodObject<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    harness: z.ZodOptional<z.ZodUnknown>;
    usage: z.ZodOptional<z.ZodNumber>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    thread: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
    index: z.ZodObject<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        entries: z.ZodArray<z.ZodUnknown, "many">;
        cursor: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    read: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    harness: z.ZodOptional<z.ZodUnknown>;
    usage: z.ZodOptional<z.ZodNumber>;
}, z.ZodTypeAny, "passthrough">>;
export declare const storeWireTurnCommitRequestSchema: z.ZodObject<{
    messages: z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">>>;
    audit: z.ZodOptional<z.ZodObject<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    messages: z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">>>;
    audit: z.ZodOptional<z.ZodObject<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    messages: z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        messages: z.ZodArray<z.ZodUnknown, "many">;
        title: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
    harness: z.ZodOptional<z.ZodObject<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        threadId: z.ZodString;
        subject: z.ZodString;
        state: z.ZodUnknown;
    }, z.ZodTypeAny, "passthrough">>>;
    audit: z.ZodOptional<z.ZodObject<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        collection: z.ZodString;
        record: z.ZodObject<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodString;
            data: z.ZodUnknown;
            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.ZodTypeAny, "passthrough">>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
/** `harness.set` answers nothing, so the envelope answers nothing for it. */
export declare const storeWireTurnCommitResponseSchema: z.ZodObject<{
    messages: z.ZodObject<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>;
    audit: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    messages: z.ZodObject<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>;
    audit: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    messages: z.ZodObject<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        revision: z.ZodString;
        count: z.ZodNumber;
    }, z.ZodTypeAny, "passthrough">>;
    audit: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodString;
        data: z.ZodType<{}, z.ZodTypeDef, {}>;
        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        revision: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>>;
}, z.ZodTypeAny, "passthrough">>;
/** The op count a mount must report on `/status` before a client may send the
    turn envelopes — read with `>=` and FROZEN, exactly as
    {@link STORE_WIRE_APPEND_MESSAGES_OPS} is, and for its reasons.
    `turn.commit` is the shape that warrants a pre-send check: a MUTATION with a
    cheaper fallback (the individual ops), where a 501 leaves the caller unable
    to tell "never ran" from "ran and failed". `turn.load` is a read that could
    be sent blind, but the two ship as one family on one level. */
export declare const STORE_WIRE_TURN_OPS = 50;
/** GET /status — the discovery handshake. Clients learn the protocol version
    and the op count. The body passes unknown keys through, so a mount that
    still sends fields this build dropped is read, not refused.

    `ops` is a LEVEL, not an inventory: how far down STORE_WIRE_PATHS' declared
    order this mount serves. It answers "are you at least as new as X" and
    nothing finer — there is no way to say "all but one in the middle", which is
    why the ops an engine may not have yet are declared last. Read it with `>=`
    against a frozen constant, and read a missing op's absence off its own 501. */
export interface StoreWireStatus {
    format: typeof VENDO_STORE_WIRE_FORMAT;
    ops: number;
}
export declare const storeWireStatusSchema: z.ZodObject<{
    format: z.ZodLiteral<"vendo/store-wire@1">;
    ops: z.ZodNumber;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    format: z.ZodLiteral<"vendo/store-wire@1">;
    ops: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    format: z.ZodLiteral<"vendo/store-wire@1">;
    ops: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">>;
/** `detail` is `VendoError.detail`, and it crosses. Without it a refusal
    arrived over the wire as a code and a sentence, so every structured payload
    a refusal carried was readable by a local caller and lost to a hosted one:
    `workspace.commit`'s conflict names the paths that moved in `detail.conflicts`,
    and the hosted path had to re-read the whole index and re-derive them by
    hand (`workspace-ops-rows.ts`). Optional, and passed through untouched — a
    mount that sends none and a client that ignores one both stay legal. */
export interface StoreWireError {
    error: {
        code: VendoErrorCode;
        message: string;
        detail?: unknown;
    };
}
export declare const storeWireErrorSchema: z.ZodObject<{
    error: z.ZodObject<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    error: z.ZodObject<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    error: z.ZodObject<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        code: z.ZodEnum<["validation", "blocked", "not-implemented", "sandbox-unavailable", "cloud-required", "not-found", "conflict", "forbidden", "unavailable", "schema-proposal"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
/** What a client can do with an answer, declared on EVERY request it sends so a
    mount never sends a shape the client cannot read. Comma-separated and
    ADDITIVE — a mount reads it as a set and ignores names it does not know, a
    client omits names it does not implement — which is what lets a mount grow an
    answer shape without a version bump. Scoped to the store wire: the other
    Cloud wires declare nothing, and managed inference does not carry Vendo
    headers at all. */
export declare const STORE_WIRE_CAPABILITIES_HEADER = "x-vendo-store-capabilities";
/** The capabilities THIS build implements — today, only the schema-proposal
    handshake below. */
export declare const STORE_WIRE_CAPABILITIES = "schema-proposal";
/** A typed mount's answer to a write against a table it has not been told
    about: HTTP 409 carrying the DDL that would make the write legal, instead of
    applying the write. `error` is the literal STRING "schema-proposal" — that is
    what discriminates this body from {@link StoreWireError}, whose `error` is an
    object, and the two have to be told apart by shape because they share a
    status.

    The proposal is passed through UNTOUCHED: the client forwards it verbatim to
    the mount's schema door, so only the two fields it reads to explain itself
    are typed here and every other field crosses on unread. */
export interface StoreWireSchemaProposal {
    error: "schema-proposal";
    proposal: {
        op: string;
        table: string;
    };
}
export declare const storeWireSchemaProposalSchema: z.ZodObject<{
    error: z.ZodLiteral<"schema-proposal">;
    proposal: z.ZodObject<{
        op: z.ZodString;
        table: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    error: z.ZodLiteral<"schema-proposal">;
    proposal: z.ZodObject<{
        op: z.ZodString;
        table: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    error: z.ZodLiteral<"schema-proposal">;
    proposal: z.ZodObject<{
        op: z.ZodString;
        table: z.ZodString;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        op: z.ZodString;
        table: z.ZodString;
    }, z.ZodTypeAny, "passthrough">>;
}, z.ZodTypeAny, "passthrough">>;
/** Mirrors the umbrella wire's STATUS_BY_CODE — core cannot import it
    (layering: core depends on nothing). */
export declare const STORE_WIRE_STATUS_BY_CODE: Record<VendoErrorCode, number>;
/** Server half: one VendoError → the enveloped body + HTTP status. */
export declare function storeWireErrorBody(error: VendoError): {
    status: number;
    body: StoreWireError;
};
/** Client half: a non-2xx response → VendoError. An enveloped wire-legal
    code wins over the bare status; a schema proposal is recognized as ITSELF,
    carrying the proposal on `detail` for the client that confirms it; recognized
    statuses map through STATUS_TO_CODE (429/5xx → "unavailable", retryable);
    anything else degrades to "not-implemented" — and says what it could not
    read, because a silently discarded body is an undiagnosable skew. */
export declare function parseStoreWireError(status: number, body: unknown): VendoError;