hide-a-bed 5.0.2 → 5.0.3

package/schema/patch.d.mts

@@ -0,0 +1,255 @@
+export const PatchProperties: z.ZodRecord<z.ZodString, z.ZodAny>;
+export const StrictPatchProperties: z.ZodIntersection<z.ZodObject<{
+    _rev: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _rev: string;
+}, {
+    _rev: string;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>>;
+export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodIntersection<z.ZodObject<{
+    _rev: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _rev: string;
+}, {
+    _rev: string;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    ok: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+    statusCode: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}>>>;
+/** @typedef { z.infer<typeof Patch> } PatchSchema */
+export const PatchBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodIntersection<z.ZodObject<{
+    _rev: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    _rev: string;
+}, {
+    _rev: string;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    ok: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+    statusCode: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}>>>;
+/** @typedef { z.infer<typeof PatchBound> } PatchBoundSchema */
+export const PatchDangerously: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    ok: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+    statusCode: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}>>>;
+/** @typedef { z.infer<typeof PatchDangerously> } PatchDangerouslySchema */
+export const PatchDangerouslyBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    ok: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+    statusCode: z.ZodNumber;
+    id: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}, {
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}>>>;
+export type PatchSchema = z.infer<typeof Patch>;
+export type PatchBoundSchema = z.infer<typeof PatchBound>;
+export type PatchDangerouslySchema = z.infer<typeof PatchDangerously>;
+export type PatchDangerouslyBoundSchema = z.infer<typeof PatchDangerouslyBound>;
+import { z } from 'zod';
+//# sourceMappingURL=patch.d.mts.map

package/schema/patch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIA,iEAA4D;AAC5D;;;;;;wCAEuB;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;AACvC,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;KAKuC;AACvC,+DAA+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;AACvC,2EAA2E;AAE3E;;;;;;;;;;;;;;;;;;KAKuC;0BAxBxB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;+BAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;qCAS1B,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC;0CAQhC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;kBAzClC,KAAK"}

package/schema/query.d.mts

@@ -0,0 +1,406 @@
+export const ViewRow: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodNullable<z.ZodAny>;
+    value: z.ZodNullable<z.ZodAny>;
+    doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    key?: any;
+    value?: any;
+    doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+    error?: string | undefined;
+}, {
+    id?: string | undefined;
+    key?: any;
+    value?: any;
+    doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+    error?: string | undefined;
+}>;
+/** @typedef { z.infer<typeof ViewRow> } ViewRowSchema */
+export const SimpleViewQueryResponse: z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+/** @typedef { z.infer<typeof SimpleViewQueryResponse> } SimpleViewQueryResponseSchema */
+export const SimpleViewOptions: z.ZodOptional<z.ZodObject<{
+    startkey: z.ZodOptional<z.ZodAny>;
+    endkey: z.ZodOptional<z.ZodAny>;
+    descending: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    key: z.ZodOptional<z.ZodAny>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    include_docs: z.ZodOptional<z.ZodBoolean>;
+    reduce: z.ZodOptional<z.ZodBoolean>;
+    group: z.ZodOptional<z.ZodBoolean>;
+    group_level: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}>>;
+/** @typedef { z.infer<typeof SimpleViewOptions> } SimpleViewOptionsSchema */
+export const SimpleViewQuery: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+    }, "strip", z.ZodTypeAny, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }, {
+        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
+    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
+    _normalizedLogger: z.ZodOptional<z.ZodAny>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodOptional<z.ZodObject<{
+    startkey: z.ZodOptional<z.ZodAny>;
+    endkey: z.ZodOptional<z.ZodAny>;
+    descending: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    key: z.ZodOptional<z.ZodAny>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    include_docs: z.ZodOptional<z.ZodBoolean>;
+    reduce: z.ZodOptional<z.ZodBoolean>;
+    group: z.ZodOptional<z.ZodBoolean>;
+    group_level: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>>>;
+/** @typedef { z.infer<typeof SimpleViewQuery> } SimpleViewQuerySchema */
+export const SimpleViewQueryBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+    startkey: z.ZodOptional<z.ZodAny>;
+    endkey: z.ZodOptional<z.ZodAny>;
+    descending: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    key: z.ZodOptional<z.ZodAny>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    include_docs: z.ZodOptional<z.ZodBoolean>;
+    reduce: z.ZodOptional<z.ZodBoolean>;
+    group: z.ZodOptional<z.ZodBoolean>;
+    group_level: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}, {
+    startkey?: any;
+    endkey?: any;
+    descending?: boolean | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    key?: any;
+    keys?: any[] | undefined;
+    include_docs?: boolean | undefined;
+    reduce?: boolean | undefined;
+    group?: boolean | undefined;
+    group_level?: number | undefined;
+}>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | null | undefined;
+        error?: string | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>>>;
+export type ViewRowSchema = z.infer<typeof ViewRow>;
+export type SimpleViewQueryResponseSchema = z.infer<typeof SimpleViewQueryResponse>;
+export type SimpleViewOptionsSchema = z.infer<typeof SimpleViewOptions>;
+export type SimpleViewQuerySchema = z.infer<typeof SimpleViewQuery>;
+export type SimpleViewQueryBoundSchema = z.infer<typeof SimpleViewQueryBound>;
+import { z } from 'zod';
+//# sourceMappingURL=query.d.mts.map

package/schema/query.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAME;AACF,yDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGgB;AAChB,yFAAyF;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYuC;AACvC,6EAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAI6C;AAC7C,yEAAyE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAG6C;4BAjC9B,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;4CAMvB,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC;sCAevC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;oCAOjC,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;yCAM/B,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;kBA5CjC,KAAK"}