hide-a-bed 5.0.2 → 5.0.3

package/impl/logger.d.mts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {Object} Logger
+ * @property {(...args: any[]) => void} error - Log error messages
+ * @property {(...args: any[]) => void} warn - Log warning messages
+ * @property {(...args: any[]) => void} info - Log info messages
+ * @property {(...args: any[]) => void} debug - Log debug messages
+ */
+/**
+ * Creates a unified logger interface that works with both function and object-style loggers
+ * @param {import('../schema/config.mjs').CouchConfigSchema} config
+ * @returns {Logger} Normalized logger interface
+ */
+export function createLogger(config: import("../schema/config.mjs").CouchConfigSchema): Logger;
+export type Logger = {
+    /**
+     * - Log error messages
+     */
+    error: (...args: any[]) => void;
+    /**
+     * - Log warning messages
+     */
+    warn: (...args: any[]) => void;
+    /**
+     * - Log info messages
+     */
+    info: (...args: any[]) => void;
+    /**
+     * - Log debug messages
+     */
+    debug: (...args: any[]) => void;
+};
+//# sourceMappingURL=logger.d.mts.map

package/impl/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","sourceRoot":"","sources":["logger.mjs"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,qCAHW,OAAO,sBAAsB,EAAE,iBAAiB,GAC9C,MAAM,CA+ClB;;;;;WAxDa,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;WACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI"}

package/impl/patch.d.mts

@@ -0,0 +1,6 @@
+export function sleep(ms: any): Promise<any>;
+/** @type { import('../schema/patch.mjs').PatchSchema } */
+export const patch: import("../schema/patch.mjs").PatchSchema;
+/** @type { import('../schema/patch.mjs').PatchDangerouslySchema } */
+export const patchDangerously: import("../schema/patch.mjs").PatchDangerouslySchema;
+//# sourceMappingURL=patch.d.mts.map

package/impl/patch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CAmBnD;AAEF,qEAAqE;AACrE,+BADY,OAAO,qBAAqB,EAAE,sBAAsB,CA4D9D"}

package/impl/query.d.mts

@@ -0,0 +1,195 @@
+/**
+ * @param {{ [key: string]: any }} options - The options object containing query parameters.
+ * @param {string[]} params - The list of parameter names to include in the query string.
+ */
+/**
+ * @param {{ [key: string]: any }} options
+ * @param {string[]} params
+ * @returns {string}
+ */
+export function queryString(options: {
+    [key: string]: any;
+} | undefined, params: string[]): string;
+/**
+ * @type { z.infer<SimpleViewQuery> }
+ * @param {import('../schema/config.mjs').CouchConfigSchema} config
+ * @param {string} view
+ * @param {import('../schema/query.mjs').SimpleViewOptionsSchema} [options]
+ */
+export const query: z.infer<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">>>>>;
+import { z } from 'zod';
+//# sourceMappingURL=query.d.mts.map

package/impl/query.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AA8FA;;;GAGG;AACH;;;;GAIG;AACH,qCAJW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,sBACtB,MAAM,EAAE,GACN,MAAM,CAoBlB;AA9GD;;;;;GAKG;AACH,oBALW,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CAgFjC;kBA1FgB,KAAK"}

package/impl/queryBuilder.d.mts

@@ -0,0 +1,94 @@
+/**
+ * @typedef {Object} QueryOptions
+ * @property {any} [key] - Exact key to match
+ * @property {any} [startkey] - Start of key range
+ * @property {any} [endkey] - End of key range
+ * @property {boolean} [reduce] - Whether to use reduce function
+ * @property {boolean} [group] - Whether to group results
+ * @property {number} [group_level] - Level at which to group
+ * @property {string} [stale] - Stale parameter value
+ * @property {number} [limit] - Max number of results
+ */
+export class QueryBuilder {
+    /**
+     * @param {any} key
+     * @returns {QueryBuilder}
+     */
+    key(key: any): QueryBuilder;
+    /**
+     * @param {any} startkey
+     * @returns {QueryBuilder}
+     */
+    startKey(startkey: any): QueryBuilder;
+    /**
+     * @param {any} endkey
+     * @returns {QueryBuilder}
+     */
+    endKey(endkey: any): QueryBuilder;
+    /**
+     * @param {boolean} reduce
+     * @returns {QueryBuilder}
+     */
+    reduce(reduce?: boolean): QueryBuilder;
+    /**
+     * @param {boolean} group
+     * @returns {QueryBuilder}
+     */
+    group(group?: boolean): QueryBuilder;
+    /**
+     * @param {number} level
+     * @returns {QueryBuilder}
+     */
+    groupLevel(level: number): QueryBuilder;
+    /**
+     * @param {string} stale
+     * @returns {QueryBuilder}
+     */
+    stale(stale: string): QueryBuilder;
+    /**
+     * @param {number} limit
+     * @returns {QueryBuilder}
+     */
+    limit(limit: number): QueryBuilder;
+    /**
+     * @returns {QueryOptions}
+     */
+    build(): QueryOptions;
+    #private;
+}
+export function createQuery(): QueryBuilder;
+export type QueryOptions = {
+    /**
+     * - Exact key to match
+     */
+    key?: any;
+    /**
+     * - Start of key range
+     */
+    startkey?: any;
+    /**
+     * - End of key range
+     */
+    endkey?: any;
+    /**
+     * - Whether to use reduce function
+     */
+    reduce?: boolean | undefined;
+    /**
+     * - Whether to group results
+     */
+    group?: boolean | undefined;
+    /**
+     * - Level at which to group
+     */
+    group_level?: number | undefined;
+    /**
+     * - Stale parameter value
+     */
+    stale?: string | undefined;
+    /**
+     * - Max number of results
+     */
+    limit?: number | undefined;
+};
+//# sourceMappingURL=queryBuilder.d.mts.map

package/impl/queryBuilder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryBuilder.d.mts","sourceRoot":"","sources":["queryBuilder.mjs"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH;IAIE;;;OAGG;IACH,SAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,mBAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,eAHW,GAAG,GACD,YAAY,CAKxB;IAED;;;OAGG;IACH,gBAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,YAAY,CAKxB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,YAAY,CAKxB;IAED;;OAEG;IACH,SAFa,YAAY,CAIxB;;CACF;AAEM,4CAA4C;;;;;UA9FrC,GAAG;;;;eACH,GAAG;;;;aACH,GAAG"}

package/impl/retry.d.mts

@@ -0,0 +1,2 @@
+export function withRetry(fn: any, options?: {}): (...args: any[]) => Promise<any>;
+//# sourceMappingURL=retry.d.mts.map

package/impl/retry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.mts","sourceRoot":"","sources":["retry.mjs"],"names":[],"mappings":"AAGA,mFAmCC"}

package/impl/stream.d.mts

@@ -0,0 +1,3 @@
+/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } queryStream */
+export const queryStream: import("../schema/stream.mjs").SimpleViewQueryStreamSchema;
+//# sourceMappingURL=stream.d.mts.map

package/impl/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AASA,uFAAuF;AACvF,0BADY,OAAO,sBAAsB,EAAE,2BAA2B,CAwFpE"}

package/impl/sugar/lock.d.mts

@@ -0,0 +1,5 @@
+/** @type {import('../../schema/sugar/lock.mjs').CreateLockSchema} */
+export const createLock: import("../../schema/sugar/lock.mjs").CreateLockSchema;
+/** @type {import('../../schema/sugar/lock.mjs').RemoveLockSchema} */
+export const removeLock: import("../../schema/sugar/lock.mjs").RemoveLockSchema;
+//# sourceMappingURL=lock.d.mts.map

package/impl/sugar/lock.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.mts","sourceRoot":"","sources":["lock.mjs"],"names":[],"mappings":"AAIA,qEAAqE;AACrE,yBADW,OAAO,6BAA6B,EAAE,gBAAgB,CA8B/D;AAEF,qEAAqE;AACrE,yBADW,OAAO,6BAA6B,EAAE,gBAAgB,CAiC/D"}

package/impl/sugar/watch.d.mts

@@ -0,0 +1,34 @@
+export const watchDocs: (args_0: import("zod").objectInputType<{
+    throwOnGetNotFound: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    couch: import("zod").ZodString;
+    bindWithRetry: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    maxRetries: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    initialDelay: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    backoffFactor: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    useConsoleLogger: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    logger: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodObject<{
+        error: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodUnknown>, import("zod").ZodVoid>>;
+        warn: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodUnknown>, import("zod").ZodVoid>>;
+        info: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodUnknown>, import("zod").ZodVoid>>;
+        debug: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodUnknown>, import("zod").ZodVoid>>;
+    }, "strip", import("zod").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;
+    }>, import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodAny], import("zod").ZodUnknown>, import("zod").ZodVoid>]>>;
+    _normalizedLogger: import("zod").ZodOptional<import("zod").ZodAny>;
+}, import("zod").ZodTypeAny, "passthrough">, args_1: string | string[], args_2: (args_0: any, ...args: unknown[]) => void, args_3: {
+    include_docs?: boolean | undefined;
+}, ...args: unknown[]) => {
+    on: (event: string, listener: (args_0: any, ...args: unknown[]) => void) => EventEmitter<[never]>;
+    removeListener: (event: string, listener: (args_0: any, ...args: unknown[]) => void) => EventEmitter<[never]>;
+    stop: () => void;
+};
+import { EventEmitter } from 'events';
+//# sourceMappingURL=watch.d.mts.map

package/impl/sugar/watch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.mts","sourceRoot":"","sources":["watch.mjs"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJE;6BAxJ2B,QAAQ"}

package/impl/trackedEmitter.d.mts

@@ -0,0 +1,8 @@
+export class TrackedEmitter extends EventEmitter<[never]> {
+    constructor(options: any);
+    delay: any;
+    emit(event: any, ...args: any[]): Promise<any>;
+}
+export function setupEmitter(config: any): any;
+import { EventEmitter } from 'events';
+//# sourceMappingURL=trackedEmitter.d.mts.map

package/impl/trackedEmitter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackedEmitter.d.mts","sourceRoot":"","sources":["trackedEmitter.mjs"],"names":[],"mappings":"AAEA;IAEE,0BAGC;IADoB,WAA0B;IAG/C,+CAiBC;CACF;AAEM,+CAGN;6BAhC4B,QAAQ"}

package/impl/transactionErrors.d.mts

@@ -0,0 +1,57 @@
+export class TransactionSetupError extends Error {
+    /**
+     * @param {string} message
+     * @param {Record<string, any>} details
+     */
+    constructor(message: string, details?: Record<string, any>);
+    details: Record<string, any>;
+}
+export class TransactionVersionConflictError extends Error {
+    /**
+     * @param {string[]} conflictingIds
+     */
+    constructor(conflictingIds: string[]);
+    conflictingIds: string[];
+}
+export class TransactionBulkOperationError extends Error {
+    /**
+     * @param {Array<{ok?: boolean|null, id?: string|null, rev?: string|null, error?: string|null, reason?: string|null}>} failedDocs
+     */
+    constructor(failedDocs: Array<{
+        ok?: boolean | null;
+        id?: string | null;
+        rev?: string | null;
+        error?: string | null;
+        reason?: string | null;
+    }>);
+    failedDocs: {
+        ok?: boolean | null;
+        id?: string | null;
+        rev?: string | null;
+        error?: string | null;
+        reason?: string | null;
+    }[];
+}
+export class TransactionRollbackError extends Error {
+    /**
+     * @param {string} message
+     * @param {Error} originalError
+     * @param {Array<{ok?: boolean|null, id?: string|null, rev?: string|null, error?: string|null, reason?: string|null}>} rollbackResults
+     */
+    constructor(message: string, originalError: Error, rollbackResults: Array<{
+        ok?: boolean | null;
+        id?: string | null;
+        rev?: string | null;
+        error?: string | null;
+        reason?: string | null;
+    }>);
+    originalError: Error;
+    rollbackResults: {
+        ok?: boolean | null;
+        id?: string | null;
+        rev?: string | null;
+        error?: string | null;
+        reason?: string | null;
+    }[];
+}
+//# sourceMappingURL=transactionErrors.d.mts.map

package/impl/transactionErrors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionErrors.d.mts","sourceRoot":"","sources":["transactionErrors.mjs"],"names":[],"mappings":"AAAA;IACE;;;OAGG;IACH,qBAHW,MAAM,YACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAM7B;IADC,6BAAsB;CAEzB;AAED;IACE;;OAEG;IACH,4BAFW,MAAM,EAAE,EAMlB;IADC,yBAAoC;CAEvC;AAED;IACE;;OAEG;IACH,wBAFW,KAAK,CAAC;QAAC,EAAE,CAAC,EAAE,OAAO,GAAC,IAAI,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC,EAMpH;IADC;aALqB,OAAO,GAAC,IAAI;aAAO,MAAM,GAAC,IAAI;cAAQ,MAAM,GAAC,IAAI;gBAAU,MAAM,GAAC,IAAI;iBAAW,MAAM,GAAC,IAAI;QAKrF;CAE/B;AAED;IACE;;;;OAIG;IACH,qBAJW,MAAM,iBACN,KAAK,mBACL,KAAK,CAAC;QAAC,EAAE,CAAC,EAAE,OAAO,GAAC,IAAI,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC,EAOpH;IAFC,qBAAkC;IAClC;aANqB,OAAO,GAAC,IAAI;aAAO,MAAM,GAAC,IAAI;cAAQ,MAAM,GAAC,IAAI;gBAAU,MAAM,GAAC,IAAI;iBAAW,MAAM,GAAC,IAAI;QAM3E;CAEzC"}

package/index.d.mts

@@ -0,0 +1,74 @@
+import { get } from './impl/crud.mjs';
+import { getAtRev } from './impl/crud.mjs';
+import { put } from './impl/crud.mjs';
+import { bulkGet } from './impl/bulk.mjs';
+import { bulkSave } from './impl/bulk.mjs';
+import { query } from './impl/query.mjs';
+import { queryStream } from './impl/stream.mjs';
+export namespace schema {
+    export { CouchConfig };
+    export { SimpleViewQuery };
+    export { SimpleViewQueryResponse };
+    export { SimpleViewQueryStream };
+    export { OnRow };
+    export { BulkSave };
+    export { BulkGet };
+    export { BulkRemove };
+    export { BulkGetDictionary };
+    export { BulkSaveTransaction };
+    export { CouchGet };
+    export { CouchPut };
+    export { CouchDoc };
+    export { CouchDocResponse };
+    export { Patch };
+    export { PatchDangerously };
+    export { CouchGetAtRev };
+    export { Bind };
+    export { Lock };
+    export { WatchDocs };
+    export { LockOptions };
+    export { CreateLock };
+    export { RemoveLock };
+    export { Changes };
+    export { ChangesOptions };
+    export { ChangesResponse };
+}
+import { patch } from './impl/patch.mjs';
+import { patchDangerously } from './impl/patch.mjs';
+import { bulkRemove } from './impl/bulk.mjs';
+import { bulkGetDictionary } from './impl/bulk.mjs';
+import { bulkSaveTransaction } from './impl/bulk.mjs';
+/** @type { import('./schema/bind.mjs').BindSchema } */
+export const bindConfig: import("./schema/bind.mjs").BindSchema;
+import { withRetry } from './impl/retry.mjs';
+import { createQuery } from './impl/queryBuilder.mjs';
+import { createLock } from './impl/sugar/lock.mjs';
+import { removeLock } from './impl/sugar/lock.mjs';
+import { CouchConfig } from './schema/config.mjs';
+import { SimpleViewQuery } from './schema/query.mjs';
+import { SimpleViewQueryResponse } from './schema/query.mjs';
+import { SimpleViewQueryStream } from './schema/stream.mjs';
+import { OnRow } from './schema/stream.mjs';
+import { BulkSave } from './schema/bulk.mjs';
+import { BulkGet } from './schema/bulk.mjs';
+import { BulkRemove } from './schema/bulk.mjs';
+import { BulkGetDictionary } from './schema/bulk.mjs';
+import { BulkSaveTransaction } from './schema/bulk.mjs';
+import { CouchGet } from './schema/crud.mjs';
+import { CouchPut } from './schema/crud.mjs';
+import { CouchDoc } from './schema/crud.mjs';
+import { CouchDocResponse } from './schema/crud.mjs';
+import { Patch } from './schema/patch.mjs';
+import { PatchDangerously } from './schema/patch.mjs';
+import { CouchGetAtRev } from './schema/crud.mjs';
+import { Bind } from './schema/bind.mjs';
+import { Lock } from './schema/sugar/lock.mjs';
+import { WatchDocs } from './schema/sugar/watch.mjs';
+import { LockOptions } from './schema/sugar/lock.mjs';
+import { CreateLock } from './schema/sugar/lock.mjs';
+import { RemoveLock } from './schema/sugar/lock.mjs';
+import { Changes } from './schema/changes.mjs';
+import { ChangesOptions } from './schema/changes.mjs';
+import { ChangesResponse } from './schema/changes.mjs';
+export { get, getAtRev, put, bulkGet, bulkSave, query, queryStream, patch, patchDangerously, bulkRemove, bulkGetDictionary, bulkSaveTransaction, withRetry, createQuery, createLock, removeLock };
+//# sourceMappingURL=index.d.mts.map

package/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mjs"],"names":[],"mappings":"oBAEmC,iBAAiB;yBAAjB,iBAAiB;oBAAjB,iBAAiB;wBADkC,iBAAiB;yBAAjB,iBAAiB;sBAMjF,kBAAkB;4BACZ,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAJP,kBAAkB;iCAAlB,kBAAkB;2BAH4B,iBAAiB;kCAAjB,iBAAiB;oCAAjB,iBAAiB;AAkDvG,uDAAuD;AACvD,yBADY,OAAO,mBAAmB,EAAE,UAAU,CA+BhD;0BAxEwB,kBAAkB;4BADhB,yBAAyB;2BAJd,uBAAuB;2BAAvB,uBAAuB;4BAOlC,qBAAqB;gCACQ,oBAAoB;wCAApB,oBAAoB;sCAEhC,qBAAqB;sBAArB,qBAAqB;yBAJoB,mBAAmB;wBAAnB,mBAAmB;2BAAnB,mBAAmB;kCAAnB,mBAAmB;oCAAnB,mBAAmB;yBAQ3B,mBAAmB;yBAAnB,mBAAmB;yBAAnB,mBAAmB;iCAAnB,mBAAmB;sBAHzD,oBAAoB;iCAApB,oBAAoB;8BAGkB,mBAAmB;qBAC5E,mBAAmB;qBAHkB,yBAAyB;0BACzD,0BAA0B;4BADM,yBAAyB;2BAAzB,yBAAyB;2BAAzB,yBAAyB;wBAH1B,sBAAsB;+BAAtB,sBAAsB;gCAAtB,sBAAsB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hide-a-bed",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
   "module": "index.mjs",
   "main": "cjs/index.cjs",