hide-a-bed 5.2.7 → 6.0.0-beta.0

package/schema/bulk.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAME;AACF,iEAAiE;AAEjE;;;;;;;;;;;;;;;;;;YAA0D;AAC1D,mEAAmE;AAEnE;;;;;;;;;;;;iCAEE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;AAC5C,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAE4C;AAC5C,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAG6C;AAC7C,yDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAE6C;AAC7C,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;AAC5C,+DAA+D;AAE/D;;;;;;;;;;;;;;;;;;cAE4C;AAC5C,yEAAyE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGE;AACF,6FAA6F;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAG+C;AAC/C,6EAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE+C;AAC/C,uFAAuF;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAI4C;AAC5C,iFAAiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;gCArE7B,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;uBAG3B,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;6BAUtC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;4BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;iCAKvB,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC;+BAM5B,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;oCAK1B,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;8CAM/B,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC;sCAMzC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;2CAKjC,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;wCAOtC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC;6CAMnC,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC;kBAlFrC,KAAK"}

package/schema/bulk.mjs

@@ -1,83 +0,0 @@
-import { z } from 'zod'
-import { CouchConfig } from './config.mjs'
-import { SimpleViewQueryResponse, ViewRow } from './query.mjs'
-import { CouchDoc } from './crud.mjs'
-
-export const BulkSaveRow = z.object({
-  ok: z.boolean().nullish(),
-  id: z.string().nullish(),
-  rev: z.string().nullish(),
-  error: z.string().nullish().describe('if an error occured, one word reason, eg conflict'),
-  reason: z.string().nullish().describe('a full error message')
-})
-/** @typedef { z.infer<typeof BulkSaveRow> } BulkSaveRowSchema */
-
-export const BulkSaveResponseSchema = z.array(BulkSaveRow)
-/** @typedef { z.infer<typeof BulkSaveResponseSchema> } Response */
-
-export const OptionalIdCouchDoc = CouchDoc.extend({
-  _id: CouchDoc.shape._id.optional()
-})
-
-export const BulkSave = z.function().args(
-  CouchConfig,
-  z.array(OptionalIdCouchDoc)
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkSave> } BulkSaveSchema */
-
-export const BulkSaveBound = z.function().args(
-  z.array(OptionalIdCouchDoc)
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkSaveBound> } BulkSaveBoundSchema */
-
-export const BulkGet = z.function().args(
-  CouchConfig,
-  z.array(z.string().describe('the ids to get'))
-).returns(z.promise(SimpleViewQueryResponse))
-/** @typedef { z.infer<typeof BulkGet> } BulkGetSchema */
-
-export const BulkGetBound = z.function().args(
-  z.array(z.string().describe('the ids to get'))
-).returns(z.promise(SimpleViewQueryResponse))
-/** @typedef { z.infer<typeof BulkGetBound> } BulkGetBoundSchema */
-
-export const BulkRemove = z.function().args(
-  CouchConfig,
-  z.array(z.string().describe('the ids to delete'))
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkRemove> } BulkRemoveSchema */
-
-export const BulkRemoveBound = z.function().args(
-  z.array(z.string().describe('the ids to delete'))
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkRemoveBound> } BulkRemoveBoundSchema */
-
-export const BulkGetDictionaryResponse = z.object({
-  found: z.record(z.string(), CouchDoc),
-  notFound: z.record(z.string(), ViewRow)
-})
-/** @typedef { z.infer<typeof BulkGetDictionaryResponse> } BulkGetDictionaryResponseSchema */
-
-export const BulkGetDictionary = z.function().args(
-  CouchConfig,
-  z.array(z.string().describe('the ids to get'))
-).returns(z.promise(BulkGetDictionaryResponse))
-/** @typedef { z.infer<typeof BulkGetDictionary> } BulkGetDictionarySchema */
-
-export const BulkGetDictionaryBound = z.function().args(
-  z.array(z.string().describe('the ids to get'))
-).returns(z.promise(BulkGetDictionaryResponse))
-/** @typedef { z.infer<typeof BulkGetDictionaryBound> } BulkGetDictionaryBoundSchema */
-
-export const BulkSaveTransaction = z.function().args(
-  CouchConfig,
-  z.string().describe('transaction id'),
-  z.array(CouchDoc)
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkSaveTransaction> } BulkSaveTransactionSchema */
-
-export const BulkSaveTransactionBound = z.function().args(
-  z.string().describe('transaction id'),
-  z.array(CouchDoc)
-).returns(z.promise(BulkSaveResponseSchema))
-/** @typedef { z.infer<typeof BulkSaveTransactionBound> } BulkSaveTransactionBoundSchema */

package/schema/changes.d.mts

@@ -1,191 +0,0 @@
-export const ChangesOptions: z.ZodObject<{
-    [x: string]: z.ZodOptional<z.ZodTypeAny>;
-}, "strip", z.ZodTypeAny, {
-    [x: string]: any;
-}, {
-    [x: string]: any;
-}>;
-/** @typedef { z.infer<typeof ChangesOptions> } ChangesOptionsSchema */
-export const ChangesResponse: z.ZodObject<{
-    id: z.ZodString;
-    seq: z.ZodNumber;
-    changes: z.ZodArray<z.ZodObject<{
-        rev: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        rev: string;
-    }, {
-        rev: string;
-    }>, "many">;
-    doc: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        _id: z.ZodString;
-        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-        _deleted: z.ZodOptional<z.ZodBoolean>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        _id: z.ZodString;
-        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-        _deleted: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        _id: z.ZodString;
-        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-        _deleted: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>>>>;
-    deleted: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    changes: {
-        rev: string;
-    }[];
-    seq: number;
-    doc?: z.objectOutputType<{
-        _id: z.ZodString;
-        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-        _deleted: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough"> | null | undefined;
-    deleted?: boolean | undefined;
-}, {
-    id: string;
-    changes: {
-        rev: string;
-    }[];
-    seq: number;
-    doc?: z.objectInputType<{
-        _id: z.ZodString;
-        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-        _deleted: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough"> | null | undefined;
-    deleted?: boolean | undefined;
-}>;
-export const ChangesEmitter: z.ZodObject<{
-    on: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    removeListener: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    stop: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodVoid>;
-}, "strip", z.ZodTypeAny, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}>;
-export const Changes: 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.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>, z.ZodObject<{
-    [x: string]: z.ZodOptional<z.ZodTypeAny>;
-}, "strip", z.ZodTypeAny, {
-    [x: string]: any;
-}, {
-    [x: string]: any;
-}>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
-    on: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    removeListener: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    stop: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodVoid>;
-}, "strip", z.ZodTypeAny, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}>>>;
-/** @typedef { z.infer<typeof Changes> } ChangesSchema */
-/** @typedef { z.infer<typeof ChangesEmitter> } ChangesEmitterSchema */
-export const ChangesBound: z.ZodFunction<z.ZodTuple<[z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>, z.ZodObject<{
-    [x: string]: z.ZodOptional<z.ZodTypeAny>;
-}, "strip", z.ZodTypeAny, {
-    [x: string]: any;
-}, {
-    [x: string]: any;
-}>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
-    on: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    removeListener: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>], z.ZodUnknown>, z.ZodAny>;
-    stop: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodVoid>;
-}, "strip", z.ZodTypeAny, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}, {
-    stop: (...args: unknown[]) => void;
-    on: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-    removeListener: (args_0: string, args_1: (args_0: any, ...args: unknown[]) => void, ...args: unknown[]) => any;
-}>>>;
-export type ChangesOptionsSchema = z.infer<typeof ChangesOptions>;
-export type ChangesSchema = z.infer<typeof Changes>;
-export type ChangesEmitterSchema = z.infer<typeof ChangesEmitter>;
-export type ChangesBoundSchema = z.infer<typeof ChangesBound>;
-import { z } from 'zod';
-//# sourceMappingURL=changes.d.mts.map

package/schema/changes.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"changes.d.mts","sourceRoot":"","sources":["changes.mjs"],"names":[],"mappings":"AAIA;;;;;;GAaY;AACZ,uEAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQE;AAEF;;;;;;;;;;;;GAQE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMqC;AAErC,yDAAyD;AACzD,uEAAuE;AAEvE;;;;;;;;;;;;;;;;;;KAKqC;mCAtCtB,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC;4BA8B9B,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;mCACvB,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC;iCAS9B,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC;kBA1DzB,KAAK"}

package/schema/changes.mjs

@@ -1,59 +0,0 @@
-import { z } from 'zod'
-import { CouchConfig } from './config.mjs'
-import { CouchDoc } from './crud.mjs'
-
-export const ChangesOptions = z.object({
-  feed: z.enum(['continuous', 'longpoll']).default('continuous'),
-  filter: z.any(), // z.union([z.string(), z.array()]).optional(),
-  inactivity_ms: z.number().default(60 * 60 * 1000),
-  /** @type {number} */
-  timeout: z.number().optional(),
-  requestTimeout: z.number().default(2 * 60 * 1000),
-  since: z.union([z.number(), z.literal('now')]).default(0),
-  heartbeat: z.number().default(30 * 1000),
-  style: z.enum(['main_only', 'all_docs']).default('main_only'),
-  include_docs: z.boolean().default(false),
-  query_params: z.record(z.any()).default({}),
-  use_post: z.boolean().default(false)
-}).partial()
-/** @typedef { z.infer<typeof ChangesOptions> } ChangesOptionsSchema */
-
-export const ChangesResponse = z.object({
-  id: z.string(),
-  seq: z.number(),
-  changes: z.array(z.object({
-    rev: z.string()
-  })),
-  doc: CouchDoc.nullish().optional(),
-  deleted: z.boolean().optional()
-})
-
-export const ChangesEmitter = z.object({
-  on: z.function()
-    .args(z.string(), z.function().args(z.any()).returns(z.void()))
-    .returns(z.any()),
-  removeListener: z.function()
-    .args(z.string(), z.function().args(z.any()).returns(z.void()))
-    .returns(z.any()),
-  stop: z.function().returns(z.void())
-})
-
-export const Changes = z.function()
-  .args(
-    CouchConfig,
-    z.function().args(z.any()).returns(z.void()),
-    ChangesOptions
-  )
-  .returns(z.promise(ChangesEmitter))
-
-/** @typedef { z.infer<typeof Changes> } ChangesSchema */
-/** @typedef { z.infer<typeof ChangesEmitter> } ChangesEmitterSchema */
-
-export const ChangesBound = z.function()
-  .args(
-    z.function().args(z.any()).returns(z.void()),
-    ChangesOptions
-  )
-  .returns(z.promise(ChangesEmitter))
-
-/** @typedef { z.infer<typeof ChangesBound> } ChangesBoundSchema */

package/schema/config.d.mts

@@ -1,79 +0,0 @@
-export const CouchConfig: 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">>;
-export type CouchConfigSchema = z.infer<typeof CouchConfig>;
-import { z } from 'zod';
-//# sourceMappingURL=config.d.mts.map

package/schema/config.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["config.mjs"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAWkD;gCAEnC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;kBAzBxB,KAAK"}

package/schema/config.mjs

@@ -1,26 +0,0 @@
-import { z } from 'zod'
-
-const LoggerSchema = z.object({
-  error: z.function().args(z.any()).returns(z.void()).optional(),
-  warn: z.function().args(z.any()).returns(z.void()).optional(),
-  info: z.function().args(z.any()).returns(z.void()).optional(),
-  debug: z.function().args(z.any()).returns(z.void()).optional()
-}).or(z.function().args(
-  z.string(), // level
-  z.any() // message/args
-).returns(z.void()))
-
-export const CouchConfig = z.object({
-  throwOnGetNotFound: z.boolean().optional().default(false).describe('if a get is 404 should we throw or return undefined'),
-  couch: z.string().describe('the url of the couch db'),
-  bindWithRetry: z.boolean().optional().default(true).describe('should we bind with retry'),
-  maxRetries: z.number().optional().default(3).describe('maximum number of retry attempts'),
-  initialDelay: z.number().optional().default(1000).describe('initial retry delay in milliseconds'),
-  backoffFactor: z.number().optional().default(2).describe('multiplier for exponential backoff'),
-  useConsoleLogger: z.boolean().optional().default(false).describe('turn on console as a fallback logger'),
-  logger: LoggerSchema.optional().describe('logging interface supporting winston-like or simple function interface'),
-  // _emitter: z.any().optional().describe('emitter for events'),
-  _normalizedLogger: z.any().optional() // Internal property for caching normalized logger
-}).passthrough().describe('The std config object')
-
-/** @typedef { z.infer<typeof CouchConfig> } CouchConfigSchema */