@rocicorp/zero 1.12.0-canary.6 → 1.12.0-canary.7

package/out/zero-cache/src/services/view-syncer/schema/types.d.ts

@@ -1,563 +0,0 @@
-import * as v from '../../../../../shared/src/valita.ts';
-import type { QueriesRow } from './cvr.ts';
-export declare const cvrVersionSchema: v.ObjectType<{
-    /**
-     * The database `stateVersion` with which the rows in the CVR are consistent.
-     */
-    stateVersion: v.Type<string>;
-    /**
-     * `configVersion` is subversion of `stateVersion` that is initially absent for each
-     * `stateVersion`, and incremented for configuration changes that affect the contents
-     * of the CVR such as:
-     *
-     * * query set changes
-     * * query transformation changes (which may happen for changes
-     *   in server-side logic or authorization policies)
-     *
-     * Such configuration changes are always correlated with a change to one or more
-     * `/meta/...` records in the CVR, often (but not always) with corresponding
-     * patches in `/patches/meta/...`.
-     *
-     * When the `stateVersion` moves forward, the `minorVersion` is reset to absent.
-     * In this manner it behaves like the analogous concept in semantic versioning.
-     */
-    configVersion: v.Optional<number>;
-}, undefined>;
-export type CVRVersion = v.Infer<typeof cvrVersionSchema>;
-export declare const EMPTY_CVR_VERSION: CVRVersion;
-export declare function oneAfter(v: NullableCVRVersion): CVRVersion;
-export type NullableCVRVersion = CVRVersion | null;
-export declare function cmpVersions(a: NullableCVRVersion, b: NullableCVRVersion): number;
-export declare function maxVersion(a: CVRVersion, b?: CVRVersion): CVRVersion;
-export declare function versionToCookie(v: CVRVersion): string;
-export declare function versionToNullableCookie(v: NullableCVRVersion): string | null;
-export declare function cookieToVersion(cookie: string | null): NullableCVRVersion;
-export declare const cvrIDSchema: v.ObjectType<{
-    id: v.Type<string>;
-}, undefined>;
-export type CvrID = v.Infer<typeof cvrIDSchema>;
-export declare const clientRecordSchema: v.ObjectType<{
-    /** The client ID, of which there can be multiple for a client group view. */
-    id: v.Type<string>;
-    /** The client's desired query IDs. Patch information is stored in the QueryRecord. */
-    desiredQueryIDs: v.ArrayType<v.Type<string>>;
-}, undefined>;
-export type ClientRecord = v.Infer<typeof clientRecordSchema>;
-export declare const baseQueryRecordSchema: v.ObjectType<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, undefined>;
-/**
- * Internal queries track rows in the database for internal use, such as the
- * `lastMutationID`s in the `zero.clients` table. They participate in the standard
- * invalidation / update logic for row contents, but not in the desired/got or
- * size-based quota logic for client-requested queries.
- */
-export declare const internalQueryRecordSchema: v.ObjectType<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "ast" | "type"> & {
-    type: v.Type<"internal">;
-    ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
-}, undefined>;
-export type InternalQueryRecord = v.Infer<typeof internalQueryRecordSchema>;
-export declare const clientQueryRecordSchema: v.ObjectType<Omit<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "clientState" | "patchVersion"> & {
-    /**
-     * The client state for this query, which includes the inactivatedAt, ttl and
-     * version. The client state is stored in a record with the client ID as the
-     * key.
-     */
-    clientState: v.Type<Record<string, {
-        inactivatedAt?: import("../ttl-clock.ts").TTLClock | undefined;
-        ttl: number;
-        version: {
-            stateVersion: string;
-            configVersion?: number | undefined;
-        };
-    }>>;
-    patchVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "ast" | "type"> & {
-    type: v.Type<"client">;
-    /** The original AST as supplied by the client. */
-    ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
-}, undefined>;
-export type ClientQueryRecord = v.Infer<typeof clientQueryRecordSchema>;
-export declare const customQueryRecordSchema: v.ObjectType<Omit<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "clientState" | "patchVersion"> & {
-    /**
-     * The client state for this query, which includes the inactivatedAt, ttl and
-     * version. The client state is stored in a record with the client ID as the
-     * key.
-     */
-    clientState: v.Type<Record<string, {
-        inactivatedAt?: import("../ttl-clock.ts").TTLClock | undefined;
-        ttl: number;
-        version: {
-            stateVersion: string;
-            configVersion?: number | undefined;
-        };
-    }>>;
-    patchVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "args" | "name" | "type"> & {
-    type: v.Type<"custom">;
-    name: v.Type<string>;
-    args: v.Type<readonly import("../../../../../shared/src/json.ts").ReadonlyJSONValue[]>;
-}, undefined>;
-export type CustomQueryRecord = v.Infer<typeof customQueryRecordSchema>;
-export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "clientState" | "patchVersion"> & {
-    /**
-     * The client state for this query, which includes the inactivatedAt, ttl and
-     * version. The client state is stored in a record with the client ID as the
-     * key.
-     */
-    clientState: v.Type<Record<string, {
-        inactivatedAt?: import("../ttl-clock.ts").TTLClock | undefined;
-        ttl: number;
-        version: {
-            stateVersion: string;
-            configVersion?: number | undefined;
-        };
-    }>>;
-    patchVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "ast" | "type"> & {
-    type: v.Type<"client">;
-    /** The original AST as supplied by the client. */
-    ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
-}, undefined>, v.ObjectType<Omit<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "clientState" | "patchVersion"> & {
-    /**
-     * The client state for this query, which includes the inactivatedAt, ttl and
-     * version. The client state is stored in a record with the client ID as the
-     * key.
-     */
-    clientState: v.Type<Record<string, {
-        inactivatedAt?: import("../ttl-clock.ts").TTLClock | undefined;
-        ttl: number;
-        version: {
-            stateVersion: string;
-            configVersion?: number | undefined;
-        };
-    }>>;
-    patchVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "args" | "name" | "type"> & {
-    type: v.Type<"custom">;
-    name: v.Type<string>;
-    args: v.Type<readonly import("../../../../../shared/src/json.ts").ReadonlyJSONValue[]>;
-}, undefined>, v.ObjectType<Omit<{
-    /** The client-specified ID used to identify this query. Typically a hash. */
-    id: v.Type<string>;
-    /**
-     * The hash of the query after server-side transformations, which include:
-     *
-     * * Normalization (which may differ from what the client does)
-     * * Query "expansion" to include primary keys and query-execution-related columns
-     * * Authorization transforms
-     *
-     * Transformations depend on conditions that are independent of the db state version,
-     * such as server-side logic and authorization policies. As such, the version of a CVR
-     * version may need to be advanced independent of db state changes. This is done
-     * via the `minorVersion` counter of the CVRVersion object, which is used to account
-     * for both changes to the query set and changes to query transformations (which are
-     * effectively remove-old-query + add-new-query).
-     *
-     * Note that the transformed AST itself is **not** stored, as the result of the previous
-     * transformation is not useful in and of itself. If the current transformation results in
-     * a different hash than that of the transformation used for the last version of the CVR,
-     * it is simply handled by invalidating the existing rows, re-executed the query with
-     * the new transformation, and advancing the CVR's `minorVersion` and this query's
-     * `transformationVersion`.
-     *
-     * Note that the transformationHash is only stored when the query has reached the "gotten"
-     * state. If the query is in the "desired" but not yet "gotten" state, the field is absent.
-     */
-    transformationHash: v.Optional<string>;
-    /**
-     * The CVR version corresponding to the `transformationHash`. This essentially tracks when
-     * this version of the query was effectively added to the CVR (as opposed to the
-     * `patchVersion`, which is simply when the client was notified that its query was added
-     * to the gotten set). Catchup of clients from old CVR versions require executing all
-     * queries with a newer `transformationVersion`.
-     */
-    transformationVersion: v.Optional<{
-        stateVersion: string;
-        configVersion?: number | undefined;
-    }>;
-}, "ast" | "type"> & {
-    type: v.Type<"internal">;
-    ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
-}, undefined>]>;
-export type QueryRecord = v.Infer<typeof queryRecordSchema>;
-export declare const rowIDSchema: v.ObjectType<{
-    schema: v.Type<string>;
-    table: v.Type<string>;
-    rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-}, undefined>;
-export type RowID = v.Infer<typeof rowIDSchema>;
-export declare const rowRecordSchema: v.ObjectType<Omit<{
-    /**
-     * CVR records store the CVRVersion at which the record was last patched into
-     * the CVR, which corresponds with a patch row that is cleaned up when the
-     * record is changed (updated, deleted, and re-added in the case of rows).
-     *
-     * Tombstones are stored for row records but not for config records. This means
-     * that "orphaned" delete patches for config records may exist, and therefore
-     * scans of config patches must always run until the end of the list. On the
-     * contrary, for row patches, the row record tombstones allow cleanup of delete
-     * patches.
-     */
-    patchVersion: v.ObjectType<{
-        /**
-         * The database `stateVersion` with which the rows in the CVR are consistent.
-         */
-        stateVersion: v.Type<string>;
-        /**
-         * `configVersion` is subversion of `stateVersion` that is initially absent for each
-         * `stateVersion`, and incremented for configuration changes that affect the contents
-         * of the CVR such as:
-         *
-         * * query set changes
-         * * query transformation changes (which may happen for changes
-         *   in server-side logic or authorization policies)
-         *
-         * Such configuration changes are always correlated with a change to one or more
-         * `/meta/...` records in the CVR, often (but not always) with corresponding
-         * patches in `/patches/meta/...`.
-         *
-         * When the `stateVersion` moves forward, the `minorVersion` is reset to absent.
-         * In this manner it behaves like the analogous concept in semantic versioning.
-         */
-        configVersion: v.Optional<number>;
-    }, undefined>;
-}, "id" | "refCounts" | "rowVersion"> & {
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        table: v.Type<string>;
-        rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, undefined>;
-    rowVersion: v.Type<string>;
-    refCounts: v.UnionType<[v.Type<null>, v.Type<Record<string, number>>]>;
-}, undefined>;
-export type RowRecord = v.Infer<typeof rowRecordSchema>;
-export declare const patchSchema: v.ObjectType<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, undefined>;
-export declare const putRowPatchSchema: v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "id" | "op" | "rowVersion" | "type"> & {
-    type: v.Type<"row">;
-    op: v.Type<"put">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        table: v.Type<string>;
-        rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, undefined>;
-    rowVersion: v.Type<string>;
-}, undefined>;
-export type PutRowPatch = v.Infer<typeof putRowPatchSchema>;
-export declare const delRowPatchSchema: v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "id" | "op" | "type"> & {
-    type: v.Type<"row">;
-    op: v.Type<"del">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        table: v.Type<string>;
-        rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, undefined>;
-}, undefined>;
-export type DelRowPatch = v.Infer<typeof delRowPatchSchema>;
-export declare const rowPatchSchema: v.UnionType<[v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "id" | "op" | "rowVersion" | "type"> & {
-    type: v.Type<"row">;
-    op: v.Type<"put">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        table: v.Type<string>;
-        rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, undefined>;
-    rowVersion: v.Type<string>;
-}, undefined>, v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "id" | "op" | "type"> & {
-    type: v.Type<"row">;
-    op: v.Type<"del">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        table: v.Type<string>;
-        rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, undefined>;
-}, undefined>]>;
-export type RowPatch = v.Infer<typeof rowPatchSchema>;
-export declare const queryPatchSchema: v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "clientID" | "id" | "type"> & {
-    type: v.Type<"query">;
-    id: v.Type<string>;
-    clientID: v.Optional<string>;
-}, undefined>;
-export type QueryPatch = v.Infer<typeof queryPatchSchema>;
-export type PutQueryPatch = QueryPatch & {
-    op: 'put';
-};
-export type DelQueryPatch = QueryPatch & {
-    op: 'del';
-};
-export declare const metadataPatchSchema: v.ObjectType<Omit<{
-    type: v.Type<"query" | "row">;
-    op: v.Type<"del" | "put">;
-}, "clientID" | "id" | "type"> & {
-    type: v.Type<"query">;
-    id: v.Type<string>;
-    clientID: v.Optional<string>;
-}, undefined>;
-export type MetadataPatch = v.Infer<typeof metadataPatchSchema>;
-export declare function versionString(v: CVRVersion): string;
-export declare function versionFromString(str: string): CVRVersion;
-export declare function queryRecordToQueryRow(clientGroupID: string, query: QueryRecord, rowSetSignature: string | null): QueriesRow;
-export declare const maybeVersionString: (v: CVRVersion | undefined) => string | null;
-//# sourceMappingURL=types.d.ts.map

package/out/zero-cache/src/services/view-syncer/schema/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/view-syncer/schema/types.ts"],"names":[],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/snapshot-row-cache.d.ts

@@ -1,95 +0,0 @@
-/**
- * The default maximum number of entries retained by a {@link SnapshotRowCache}.
- *
- * Each entry is a raw SQLite row (or the list of rows conflicting with
- * a row on its unique keys) read while computing a snapshot diff. A
- * replicated transaction of N rows produces up to 2N entries (the new value
- * and the previous value(s) of each row), so the cache should be large enough
- * to hold the largest transactions that are commonly replicated in order for
- * all of the client groups on a worker to share the reads.
- */
-export declare const DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES = 50000;
-/**
- * How a statement's results are read: a single row (`Statement.get()`) or
- * all rows (`Statement.all()`).
- */
-export type ReadMode = 'get' | 'all';
-/**
- * The maximum number of distinct SQL statements interned by a
- * {@link SnapshotRowCache} before it is cleared. There is one per table and
- * lookup shape, so this is only reached after many schema changes.
- */
-export declare const MAX_INTERNED_STATEMENTS = 10000;
-/**
- * A worker-wide, bounded cache of the rows that a `Snapshotter` reads from
- * replica snapshots when computing the diff between two versions of the
- * replica.
- *
- * Every client group (i.e. view-syncer) on a sync worker computes its own
- * diff from the shared `_zero.changeLog2`, and each change in the diff costs
- * two SQLite reads: the new value of the row (from the `curr` snapshot) and
- * the previous value(s) that it replaces (from the `prev` snapshot). The
- * reads for a given change are identical for every client group that
- * traverses it, so a replicated transaction of N rows costs N × 2 × (client
- * groups) reads per worker, most of which are redundant. This cache lets the
- * client groups on a worker share those reads.
- *
- * ### Keys
- *
- * Entries are keyed by the exact SQL statement and arguments of the read
- * (which encodes the table, the selected columns and the lookup keys), plus
- * a `tag` supplied by the caller that pins the result to a version of the
- * replica:
- *
- * - The new value of a row is the row as of the `stateVersion` recorded in
- *   its change log entry (its `_0_version` is asserted to equal that
- *   version), and is tagged with that `stateVersion`. It is thus shareable
- *   by all client groups regardless of the snapshots they are advancing
- *   between.
- * - Previous values are read from the `prev` snapshot at its version, and
- *   are tagged with that version (and, when the result can depend on the
- *   changes applied to the snapshot before the read, the `curr` version
- *   as well). See `Diff` in `snapshotter.ts` for the details.
- *
- * Because every key includes the version(s) that the result depends on,
- * entries never go stale and are never invalidated; they are only evicted.
- *
- * ### Eviction
- *
- * The cache is bounded by entry count and evicts in insertion (FIFO) order
- * rather than by recency. Diffs are traversed in change log order by every
- * client group, so the entries that will not be needed again are those that
- * were inserted the earliest (all groups have moved past them), while the
- * most recently inserted entries are the ones that the trailing groups have
- * yet to reach. Refreshing an entry on a hit would evict exactly the wrong
- * entries when a trailing group catches up.
- *
- * ### Sharing
- *
- * Cached values are shared by reference across client groups and must
- * therefore never be mutated by callers.
- */
-export declare class SnapshotRowCache {
-    #private;
-    constructor(maxEntries?: number);
-    get size(): number;
-    get maxEntries(): number;
-    stats(): {
-        hits: number;
-        misses: number;
-        size: number;
-    };
-    /**
-     * Returns the cached result of the read identified by `tag`, `sql`, `mode`
-     * and `args`, or performs the read via `read()`, caching and returning its
-     * result. `undefined` results (i.e. a missing row) are not cached.
-     *
-     * `mode` is part of the key because the same statement can be read both
-     * ways: for a table whose only unique key is its primary key, `getRow()`
-     * and `getRows()` produce identical SQL, args and tags, but the former
-     * caches a row and the latter an array of rows.
-     */
-    getOrRead<T>(tag: string, sql: string, mode: ReadMode, args: unknown[], read: () => T): T;
-    clear(): void;
-}
-//# sourceMappingURL=snapshot-row-cache.d.ts.map

package/out/zero-cache/src/services/view-syncer/snapshot-row-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-row-cache.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshot-row-cache.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,eAAO,MAAM,sCAAsC,QAAS,CAAC;AAwB7D;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAK9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,gBAAgB;;IAmB3B,YAAY,UAAU,SAAyC,EAE9D;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,KAAK,IAAI;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAEpD;IAED;;;;;;;;;OASG;IACH,SAAS,CAAC,CAAC,EACT,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,OAAO,EAAE,EACf,IAAI,EAAE,MAAM,CAAC,GACZ,CAAC,CAoBH;IAED,KAAK,IAAI,IAAI,CAIZ;CAsBF"}