hide-a-bed 4.0.3 → 4.1.2

package/schema/bulk.mjs

@@ -1,40 +1,40 @@
 import { z } from 'zod'
 import { CouchConfig } from './config.mjs'
+import { SimpleViewQueryResponse, ViewRow } from './query.mjs'
 import { CouchDoc } from './crud.mjs'
 
-export const BulkSaveResponseSchema = z.array(z.object({
+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 BulkSave = z.function().args(
   CouchConfig,
-  z.array(z.object({
-    _id: z.string()
-  }).passthrough())
+  z.array(CouchDoc)
 ).returns(z.promise(BulkSaveResponseSchema))
 /** @typedef { z.infer<typeof BulkSave> } BulkSaveSchema */
 
 export const BulkSaveBound = z.function().args(
-  z.array(z.object({
-    _id: z.string()
-  }).passthrough())
+  z.array(CouchDoc)
 ).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(z.array(CouchDoc.nullable())))
+).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(z.array(CouchDoc.nullable())))
+).returns(z.promise(SimpleViewQueryResponse))
 /** @typedef { z.infer<typeof BulkGetBound> } BulkGetBoundSchema */
 
 export const BulkRemove = z.function().args(
@@ -47,3 +47,33 @@ 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/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["config.mjs"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUkD;gCAEnC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;kBAxBxB,KAAK"}
+{"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

@@ -19,6 +19,7 @@ export const CouchConfig = z.object({
   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')
 

package/schema/crud.d.mts

@@ -1,12 +1,15 @@
 export const CouchDoc: z.ZodObject<{
     _id: z.ZodString;
-    _rev: z.ZodOptional<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.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.ZodString>;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>;
 /** @typedef { z.infer<typeof CouchDoc> } CouchDocSchema */
 export const CouchDocResponse: z.ZodObject<{
@@ -28,6 +31,7 @@ export const CouchDocResponse: z.ZodObject<{
     id?: string | undefined;
     rev?: string | undefined;
 }>;
+/** @typedef { z.infer<typeof CouchDocResponse> } CouchDocResponseSchema */
 export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     couch: z.ZodString;
@@ -105,13 +109,16 @@ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     _normalizedLogger: z.ZodOptional<z.ZodAny>;
 }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
     _id: z.ZodString;
-    _rev: z.ZodOptional<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.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.ZodString>;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
     ok: z.ZodOptional<z.ZodBoolean>;
     error: z.ZodOptional<z.ZodString>;
@@ -134,13 +141,16 @@ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
 /** @typedef { z.infer<typeof CouchPut> } CouchPutSchema */
 export const CouchPutBound: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     _id: z.ZodString;
-    _rev: z.ZodOptional<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.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.ZodString>;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
     ok: z.ZodOptional<z.ZodBoolean>;
     error: z.ZodOptional<z.ZodString>;
@@ -238,29 +248,244 @@ export const CouchGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     _normalizedLogger: z.ZodOptional<z.ZodAny>;
 }, z.ZodTypeAny, "passthrough">>, z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodObject<{
     _id: z.ZodString;
-    _rev: z.ZodOptional<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.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.ZodString>;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>>>>;
 /** @typedef { z.infer<typeof CouchGet> } CouchGetSchema */
 export const CouchGetBound: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodObject<{
     _id: z.ZodString;
-    _rev: z.ZodOptional<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.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.ZodString>;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>>>>;
+/** @typedef { z.infer<typeof CouchGetBound> } CouchBoundSchema */
+export const CouchGetAtRev: 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.ZodString], z.ZodUnknown>, z.ZodPromise<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">>>>>;
+/** @typedef { z.infer<typeof CouchGetAtRev> } CouchGetAtRevSchema */
+export const CouchGetAtRevBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodString], z.ZodUnknown>, z.ZodPromise<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">>>>>;
+/** @typedef { z.infer<typeof CouchGetAtRevBound> } CouchGetAtRevBoundSchema */
+export const CouchGetOptions: z.ZodObject<{
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    rev?: string | undefined;
+}, {
+    rev?: string | undefined;
+}>;
+export const CouchGetWithOptions: 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.ZodObject<{
+    rev: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    rev?: string | undefined;
+}, {
+    rev?: string | undefined;
+}>], z.ZodUnknown>, z.ZodPromise<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">>>>>;
 export type CouchDocSchema = z.infer<typeof CouchDoc>;
+export type CouchDocResponseSchema = z.infer<typeof CouchDocResponse>;
 export type CouchPutSchema = z.infer<typeof CouchPut>;
 export type CouchPutBoundSchema = z.infer<typeof CouchPutBound>;
 export type CouchGetSchema = z.infer<typeof CouchGet>;
 export type CouchBoundSchema = z.infer<typeof CouchGetBound>;
+export type CouchGetAtRevSchema = z.infer<typeof CouchGetAtRev>;
+export type CouchGetAtRevBoundSchema = z.infer<typeof CouchGetAtRevBound>;
+export type CouchGetWithOptionsSchema = z.infer<typeof CouchGetWithOptions>;
 import { z } from 'zod';
 //# sourceMappingURL=crud.d.mts.map

package/schema/crud.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;iCAGgB;AAChB,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;GAME;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGsC;AACtC,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEsC;AACtC,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAGyC;AACzC,2DAA2D;AAE3D;;;;;;;;;oCAEyC;6BA7B1B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;6BAcxB,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;6BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;+BAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;kBArC1B,KAAK"}
+{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;;;;iCAIgB;AAChB,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;GAME;AACF,2EAA2E;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGsC;AACtC,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEsC;AACtC,qEAAqE;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAGyC;AACzC,2DAA2D;AAE3D;;;;;;;;;;;;oCAEyC;AACzC,kEAAkE;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAIyC;AACzC,qEAAqE;AAErE;;;;;;;;;;;;oCAGyC;AACzC,+EAA+E;AAE/E;;;;;;GAEE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAIyC;6BAtD1B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;qCASxB,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC;6BAMhC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kCAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;6BAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;+BAKxB,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;kCAO7B,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC;uCAM7B,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC;wCAWlC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC;kBA/DhC,KAAK"}

package/schema/crud.mjs

@@ -3,7 +3,8 @@ import { CouchConfig } from './config.mjs'
 
 export const CouchDoc = z.object({
   _id: z.string().describe('the couch doc id'),
-  _rev: z.string().optional().describe('the doc revision')
+  _rev: z.string().optional().nullish().describe('the doc revision'),
+  _deleted: z.boolean().optional().describe('is the doc deleted')
 }).passthrough()
 /** @typedef { z.infer<typeof CouchDoc> } CouchDocSchema */
 
@@ -14,6 +15,7 @@ export const CouchDocResponse = z.object({
   id: z.string().optional().describe('the couch doc id'),
   rev: z.string().optional().describe('the new rev of the doc')
 })
+/** @typedef { z.infer<typeof CouchDocResponse> } CouchDocResponseSchema */
 
 export const CouchPut = z.function().args(
   CouchConfig,
@@ -36,3 +38,27 @@ export const CouchGetBound = z.function().args(
   z.string().describe('the couch doc id')
 ).returns(z.promise(CouchDoc.nullable()))
 /** @typedef { z.infer<typeof CouchGetBound> } CouchBoundSchema */
+
+export const CouchGetAtRev = z.function().args(
+  CouchConfig,
+  z.string().describe('the couch doc id'),
+  z.string().describe('the rev')
+).returns(z.promise(CouchDoc.nullable()))
+/** @typedef { z.infer<typeof CouchGetAtRev> } CouchGetAtRevSchema */
+
+export const CouchGetAtRevBound = z.function().args(
+  z.string().describe('the couch doc id'),
+  z.string().describe('the rev')
+).returns(z.promise(CouchDoc.nullable()))
+/** @typedef { z.infer<typeof CouchGetAtRevBound> } CouchGetAtRevBoundSchema */
+
+export const CouchGetOptions = z.object({
+  rev: z.string().optional().describe('the couch doc revision')
+})
+
+export const CouchGetWithOptions = z.function().args(
+  CouchConfig,
+  z.string().describe('the couch doc id'),
+  CouchGetOptions
+).returns(z.promise(CouchDoc.nullable()))
+/** @typedef { z.infer<typeof CouchGetWithOptions> } CouchGetWithOptionsSchema */

package/schema/patch.d.mts

@@ -1,4 +1,11 @@
 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;
@@ -74,7 +81,13 @@ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
         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<{
+}, 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;
@@ -94,7 +107,128 @@ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
     rev?: string | undefined;
 }>>>;
 /** @typedef { z.infer<typeof Patch> } PatchSchema */
-export const PatchBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
+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;
@@ -115,5 +249,7 @@ export const PatchBound: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.Zo
 }>>>;
 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

@@ -1 +1 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIA,iEAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;AACvC,qDAAqD;AAErD;;;;;;;;;;;;;;;;;;KAKuC;0BAPxB,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;+BAQrB,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;kBArBvB,KAAK"}
+{"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"}