hide-a-bed 3.0.0 → 4.0.0

package/schema/bind.d.mts

@@ -0,0 +1,470 @@
+export const Bind: 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>>;
+    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>>;
+    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>>;
+    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.ZodUnknown>, z.ZodObject<{
+    bulkGet: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>>;
+    bulkSave: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        _id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
+        ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }, {
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }>, "many">>>;
+    get: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodObject<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>>>;
+    put: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>], 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;
+    }>>>;
+    patch: 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;
+    }>>>;
+    query: 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>;
+        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;
+        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;
+        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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | 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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | 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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>>;
+    queryStream: 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>;
+        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;
+        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;
+        include_docs?: boolean | undefined;
+        reduce?: boolean | undefined;
+        group?: boolean | undefined;
+        group_level?: number | undefined;
+    }>>, z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodNullable<z.ZodAny>;
+        value: z.ZodNullable<z.ZodAny>;
+        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }>], z.ZodUnknown>, z.ZodUndefined>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
+}, "strip", z.ZodTypeAny, {
+    query: (args_0: string, args_1: {
+        startkey?: any;
+        endkey?: any;
+        descending?: boolean | undefined;
+        skip?: number | undefined;
+        limit?: number | undefined;
+        key?: any;
+        include_docs?: boolean | undefined;
+        reduce?: boolean | undefined;
+        group?: boolean | undefined;
+        group_level?: number | undefined;
+    } | undefined, ...args: unknown[]) => Promise<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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }>, "many">;
+    }, z.ZodTypeAny, "passthrough">>;
+    get: (args_0: string, ...args: unknown[]) => Promise<z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | null>;
+    patch: (args_0: string, args_1: Record<string, any>, ...args: unknown[]) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    put: (args_0: z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    bulkGet: (args_0: string[], ...args: unknown[]) => Promise<z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">[]>;
+    bulkSave: (args_0: z.objectInputType<{
+        _id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[], ...args: unknown[]) => Promise<{
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }[]>;
+    queryStream: (args_0: string, args_1: {
+        startkey?: any;
+        endkey?: any;
+        descending?: boolean | undefined;
+        skip?: number | undefined;
+        limit?: number | undefined;
+        key?: any;
+        include_docs?: boolean | undefined;
+        reduce?: boolean | undefined;
+        group?: boolean | undefined;
+        group_level?: number | undefined;
+    } | undefined, args_2: (args_0: {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, ...args: unknown[]) => undefined, ...args: unknown[]) => Promise<undefined>;
+}, {
+    query: (args_0: string, args_1: {
+        startkey?: any;
+        endkey?: any;
+        descending?: boolean | undefined;
+        skip?: number | undefined;
+        limit?: number | undefined;
+        key?: any;
+        include_docs?: boolean | undefined;
+        reduce?: boolean | undefined;
+        group?: boolean | undefined;
+        group_level?: number | undefined;
+    } | undefined, ...args: unknown[]) => Promise<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.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }, {
+            id?: string | undefined;
+            key?: any;
+            value?: any;
+            doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+        }>, "many">;
+    }, z.ZodTypeAny, "passthrough">>;
+    get: (args_0: string, ...args: unknown[]) => Promise<z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | null>;
+    patch: (args_0: string, args_1: Record<string, any>, ...args: unknown[]) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    put: (args_0: z.objectOutputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    bulkGet: (args_0: string[], ...args: unknown[]) => Promise<z.objectInputType<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">[]>;
+    bulkSave: (args_0: z.objectOutputType<{
+        _id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[], ...args: unknown[]) => Promise<{
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }[]>;
+    queryStream: (args_0: string, args_1: {
+        startkey?: any;
+        endkey?: any;
+        descending?: boolean | undefined;
+        skip?: number | undefined;
+        limit?: number | undefined;
+        key?: any;
+        include_docs?: boolean | undefined;
+        reduce?: boolean | undefined;
+        group?: boolean | undefined;
+        group_level?: number | undefined;
+    } | undefined, args_2: (args_0: {
+        id?: string | undefined;
+        key?: any;
+        value?: any;
+        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    }, ...args: unknown[]) => undefined, ...args: unknown[]) => Promise<undefined>;
+}>>;
+export type BindSchema = z.infer<typeof Bind>;
+import { z } from 'zod';
+//# sourceMappingURL=bind.d.mts.map

package/schema/bind.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.mts","sourceRoot":"","sources":["bind.mjs"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuE;yBACxD,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC;kBAnBjB,KAAK"}

package/schema/bind.mjs

@@ -0,0 +1,21 @@
+// @ts-check
+import { z } from 'zod'
+import { CouchConfig } from './config.mjs'
+import { BulkSaveBound, BulkGetBound } from './bulk.mjs'
+import { CouchGetBound, CouchPutBound } from './crud.mjs'
+import { PatchBound } from './patch.mjs'
+import { SimpleViewQueryBound } from './query.mjs'
+import { SimpleViewQueryStreamBound } from './stream.mjs'
+
+const BindReturns = z.object({
+  bulkGet: BulkGetBound,
+  bulkSave: BulkSaveBound,
+  get: CouchGetBound,
+  put: CouchPutBound,
+  patch: PatchBound,
+  query: SimpleViewQueryBound,
+  queryStream: SimpleViewQueryStreamBound
+})
+
+export const Bind = z.function().args(CouchConfig).returns(BindReturns)
+/** @typedef { z.infer<typeof Bind> } BindSchema */