hide-a-bed 4.0.1 → 4.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. package/cjs/impl/bulk.cjs +1 -8
  2. package/cjs/impl/logger.cjs +19 -10
  3. package/cjs/impl/patch.cjs +21 -2
  4. package/cjs/impl/query.cjs +18 -2
  5. package/cjs/impl/stream.cjs +10 -2
  6. package/cjs/index.cjs +1 -0
  7. package/cjs/schema/config.cjs +1 -0
  8. package/cjs/schema/stream.cjs +1 -1
  9. package/impl/bulk.d.mts +7 -0
  10. package/impl/bulk.d.mts.map +1 -0
  11. package/impl/bulk.mjs +4 -12
  12. package/impl/crud.d.mts +5 -0
  13. package/impl/crud.d.mts.map +1 -0
  14. package/impl/crud.mjs +7 -7
  15. package/impl/errors.d.mts +35 -0
  16. package/impl/errors.d.mts.map +1 -0
  17. package/impl/errors.mjs +11 -11
  18. package/impl/logger.d.mts +32 -0
  19. package/impl/logger.d.mts.map +1 -0
  20. package/impl/logger.mjs +1 -1
  21. package/impl/patch.d.mts +4 -0
  22. package/impl/patch.d.mts.map +1 -0
  23. package/impl/patch.mjs +6 -7
  24. package/impl/query.d.mts +173 -0
  25. package/impl/query.d.mts.map +1 -0
  26. package/impl/query.mjs +1 -5
  27. package/impl/retry.d.mts +2 -0
  28. package/impl/retry.d.mts.map +1 -0
  29. package/impl/retry.mjs +3 -3
  30. package/impl/stream.d.mts +3 -0
  31. package/impl/stream.d.mts.map +1 -0
  32. package/impl/stream.mjs +9 -25
  33. package/index.d.mts +41 -0
  34. package/index.d.mts.map +1 -0
  35. package/index.mjs +1 -1
  36. package/package.json +1 -1
  37. package/schema/bind.d.mts +473 -0
  38. package/schema/bind.d.mts.map +1 -0
  39. package/schema/bulk.d.mts +367 -0
  40. package/schema/bulk.d.mts.map +1 -0
  41. package/schema/config.d.mts +79 -0
  42. package/schema/config.d.mts.map +1 -0
  43. package/schema/config.mjs +2 -2
  44. package/schema/crud.d.mts +266 -0
  45. package/schema/crud.d.mts.map +1 -0
  46. package/schema/patch.d.mts +119 -0
  47. package/schema/patch.d.mts.map +1 -0
  48. package/schema/query.d.mts +365 -0
  49. package/schema/query.d.mts.map +1 -0
  50. package/schema/query.mjs +1 -1
  51. package/schema/stream.d.mts +196 -0
  52. package/schema/stream.d.mts.map +1 -0
package/schema/bind.d.mts ADDED
@@ -0,0 +1,473 @@
1
+ export const Bind: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
2
+ throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
3
+ couch: z.ZodString;
4
+ bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
5
+ maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
6
+ initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
7
+ backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
8
+ useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
9
+ logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
10
+ error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
11
+ warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
12
+ info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
13
+ debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
14
+ }, "strip", z.ZodTypeAny, {
15
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
16
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
17
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
18
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
19
+ }, {
20
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
21
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
22
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
23
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
24
+ }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
25
+ _normalizedLogger: z.ZodOptional<z.ZodAny>;
26
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
27
+ throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
28
+ couch: z.ZodString;
29
+ bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
30
+ maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
31
+ initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
32
+ backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
33
+ useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
34
+ logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
35
+ error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
36
+ warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
37
+ info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
38
+ debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
39
+ }, "strip", z.ZodTypeAny, {
40
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
41
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
42
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
43
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
44
+ }, {
45
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
46
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
47
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
48
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
49
+ }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
50
+ _normalizedLogger: z.ZodOptional<z.ZodAny>;
51
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
52
+ throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
53
+ couch: z.ZodString;
54
+ bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
55
+ maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
56
+ initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
57
+ backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
58
+ useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
59
+ logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
60
+ error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
61
+ warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
62
+ info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
63
+ debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
64
+ }, "strip", z.ZodTypeAny, {
65
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
66
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
67
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
68
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
69
+ }, {
70
+ error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
71
+ warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
72
+ info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
73
+ debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
74
+ }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
75
+ _normalizedLogger: z.ZodOptional<z.ZodAny>;
76
+ }, z.ZodTypeAny, "passthrough">>], z.ZodUnknown>, z.ZodObject<{
77
+ bulkGet: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
78
+ _id: z.ZodString;
79
+ _rev: z.ZodOptional<z.ZodString>;
80
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
81
+ _id: z.ZodString;
82
+ _rev: z.ZodOptional<z.ZodString>;
83
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
84
+ _id: z.ZodString;
85
+ _rev: z.ZodOptional<z.ZodString>;
86
+ }, z.ZodTypeAny, "passthrough">>, "many">>>;
87
+ bulkSave: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodObject<{
88
+ _id: z.ZodString;
89
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
90
+ _id: z.ZodString;
91
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
92
+ _id: z.ZodString;
93
+ }, z.ZodTypeAny, "passthrough">>, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
94
+ ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
95
+ id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
96
+ rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
97
+ error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
98
+ reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
99
+ }, "strip", z.ZodTypeAny, {
100
+ ok?: boolean | null | undefined;
101
+ id?: string | null | undefined;
102
+ rev?: string | null | undefined;
103
+ error?: string | null | undefined;
104
+ reason?: string | null | undefined;
105
+ }, {
106
+ ok?: boolean | null | undefined;
107
+ id?: string | null | undefined;
108
+ rev?: string | null | undefined;
109
+ error?: string | null | undefined;
110
+ reason?: string | null | undefined;
111
+ }>, "many">>>;
112
+ get: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodObject<{
113
+ _id: z.ZodString;
114
+ _rev: z.ZodOptional<z.ZodString>;
115
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
116
+ _id: z.ZodString;
117
+ _rev: z.ZodOptional<z.ZodString>;
118
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
119
+ _id: z.ZodString;
120
+ _rev: z.ZodOptional<z.ZodString>;
121
+ }, z.ZodTypeAny, "passthrough">>>>>;
122
+ put: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
123
+ _id: z.ZodString;
124
+ _rev: z.ZodOptional<z.ZodString>;
125
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
126
+ _id: z.ZodString;
127
+ _rev: z.ZodOptional<z.ZodString>;
128
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
129
+ _id: z.ZodString;
130
+ _rev: z.ZodOptional<z.ZodString>;
131
+ }, z.ZodTypeAny, "passthrough">>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
132
+ ok: z.ZodOptional<z.ZodBoolean>;
133
+ error: z.ZodOptional<z.ZodString>;
134
+ statusCode: z.ZodNumber;
135
+ id: z.ZodOptional<z.ZodString>;
136
+ rev: z.ZodOptional<z.ZodString>;
137
+ }, "strip", z.ZodTypeAny, {
138
+ statusCode: number;
139
+ ok?: boolean | undefined;
140
+ error?: string | undefined;
141
+ id?: string | undefined;
142
+ rev?: string | undefined;
143
+ }, {
144
+ statusCode: number;
145
+ ok?: boolean | undefined;
146
+ error?: string | undefined;
147
+ id?: string | undefined;
148
+ rev?: string | undefined;
149
+ }>>>;
150
+ patch: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
151
+ ok: z.ZodOptional<z.ZodBoolean>;
152
+ error: z.ZodOptional<z.ZodString>;
153
+ statusCode: z.ZodNumber;
154
+ id: z.ZodOptional<z.ZodString>;
155
+ rev: z.ZodOptional<z.ZodString>;
156
+ }, "strip", z.ZodTypeAny, {
157
+ statusCode: number;
158
+ ok?: boolean | undefined;
159
+ error?: string | undefined;
160
+ id?: string | undefined;
161
+ rev?: string | undefined;
162
+ }, {
163
+ statusCode: number;
164
+ ok?: boolean | undefined;
165
+ error?: string | undefined;
166
+ id?: string | undefined;
167
+ rev?: string | undefined;
168
+ }>>>;
169
+ query: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
170
+ startkey: z.ZodOptional<z.ZodAny>;
171
+ endkey: z.ZodOptional<z.ZodAny>;
172
+ descending: z.ZodOptional<z.ZodBoolean>;
173
+ skip: z.ZodOptional<z.ZodNumber>;
174
+ limit: z.ZodOptional<z.ZodNumber>;
175
+ key: z.ZodOptional<z.ZodAny>;
176
+ include_docs: z.ZodOptional<z.ZodBoolean>;
177
+ reduce: z.ZodOptional<z.ZodBoolean>;
178
+ group: z.ZodOptional<z.ZodBoolean>;
179
+ group_level: z.ZodOptional<z.ZodNumber>;
180
+ }, "strip", z.ZodTypeAny, {
181
+ startkey?: any;
182
+ endkey?: any;
183
+ descending?: boolean | undefined;
184
+ skip?: number | undefined;
185
+ limit?: number | undefined;
186
+ key?: any;
187
+ include_docs?: boolean | undefined;
188
+ reduce?: boolean | undefined;
189
+ group?: boolean | undefined;
190
+ group_level?: number | undefined;
191
+ }, {
192
+ startkey?: any;
193
+ endkey?: any;
194
+ descending?: boolean | undefined;
195
+ skip?: number | undefined;
196
+ limit?: number | undefined;
197
+ key?: any;
198
+ include_docs?: boolean | undefined;
199
+ reduce?: boolean | undefined;
200
+ group?: boolean | undefined;
201
+ group_level?: number | undefined;
202
+ }>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
203
+ error: z.ZodOptional<z.ZodString>;
204
+ rows: z.ZodArray<z.ZodObject<{
205
+ id: z.ZodOptional<z.ZodString>;
206
+ key: z.ZodNullable<z.ZodAny>;
207
+ value: z.ZodNullable<z.ZodAny>;
208
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
209
+ }, "strip", z.ZodTypeAny, {
210
+ id?: string | undefined;
211
+ key?: any;
212
+ value?: any;
213
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
214
+ }, {
215
+ id?: string | undefined;
216
+ key?: any;
217
+ value?: any;
218
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
219
+ }>, "many">;
220
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
221
+ error: z.ZodOptional<z.ZodString>;
222
+ rows: z.ZodArray<z.ZodObject<{
223
+ id: z.ZodOptional<z.ZodString>;
224
+ key: z.ZodNullable<z.ZodAny>;
225
+ value: z.ZodNullable<z.ZodAny>;
226
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
227
+ }, "strip", z.ZodTypeAny, {
228
+ id?: string | undefined;
229
+ key?: any;
230
+ value?: any;
231
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
232
+ }, {
233
+ id?: string | undefined;
234
+ key?: any;
235
+ value?: any;
236
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
237
+ }>, "many">;
238
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
239
+ error: z.ZodOptional<z.ZodString>;
240
+ rows: z.ZodArray<z.ZodObject<{
241
+ id: z.ZodOptional<z.ZodString>;
242
+ key: z.ZodNullable<z.ZodAny>;
243
+ value: z.ZodNullable<z.ZodAny>;
244
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
245
+ }, "strip", z.ZodTypeAny, {
246
+ id?: string | undefined;
247
+ key?: any;
248
+ value?: any;
249
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
250
+ }, {
251
+ id?: string | undefined;
252
+ key?: any;
253
+ value?: any;
254
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
255
+ }>, "many">;
256
+ }, z.ZodTypeAny, "passthrough">>>>;
257
+ queryStream: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
258
+ startkey: z.ZodOptional<z.ZodAny>;
259
+ endkey: z.ZodOptional<z.ZodAny>;
260
+ descending: z.ZodOptional<z.ZodBoolean>;
261
+ skip: z.ZodOptional<z.ZodNumber>;
262
+ limit: z.ZodOptional<z.ZodNumber>;
263
+ key: z.ZodOptional<z.ZodAny>;
264
+ include_docs: z.ZodOptional<z.ZodBoolean>;
265
+ reduce: z.ZodOptional<z.ZodBoolean>;
266
+ group: z.ZodOptional<z.ZodBoolean>;
267
+ group_level: z.ZodOptional<z.ZodNumber>;
268
+ }, "strip", z.ZodTypeAny, {
269
+ startkey?: any;
270
+ endkey?: any;
271
+ descending?: boolean | undefined;
272
+ skip?: number | undefined;
273
+ limit?: number | undefined;
274
+ key?: any;
275
+ include_docs?: boolean | undefined;
276
+ reduce?: boolean | undefined;
277
+ group?: boolean | undefined;
278
+ group_level?: number | undefined;
279
+ }, {
280
+ startkey?: any;
281
+ endkey?: any;
282
+ descending?: boolean | undefined;
283
+ skip?: number | undefined;
284
+ limit?: number | undefined;
285
+ key?: any;
286
+ include_docs?: boolean | undefined;
287
+ reduce?: boolean | undefined;
288
+ group?: boolean | undefined;
289
+ group_level?: number | undefined;
290
+ }>>, z.ZodFunction<z.ZodTuple<[z.ZodObject<{
291
+ id: z.ZodOptional<z.ZodString>;
292
+ key: z.ZodNullable<z.ZodAny>;
293
+ value: z.ZodNullable<z.ZodAny>;
294
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
295
+ }, "strip", z.ZodTypeAny, {
296
+ id?: string | undefined;
297
+ key?: any;
298
+ value?: any;
299
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
300
+ }, {
301
+ id?: string | undefined;
302
+ key?: any;
303
+ value?: any;
304
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
305
+ }>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodPromise<z.ZodUndefined>>;
306
+ }, "strip", z.ZodTypeAny, {
307
+ query: (args_0: string, args_1: {
308
+ startkey?: any;
309
+ endkey?: any;
310
+ descending?: boolean | undefined;
311
+ skip?: number | undefined;
312
+ limit?: number | undefined;
313
+ key?: any;
314
+ include_docs?: boolean | undefined;
315
+ reduce?: boolean | undefined;
316
+ group?: boolean | undefined;
317
+ group_level?: number | undefined;
318
+ } | undefined, ...args: unknown[]) => Promise<z.objectOutputType<{
319
+ error: z.ZodOptional<z.ZodString>;
320
+ rows: z.ZodArray<z.ZodObject<{
321
+ id: z.ZodOptional<z.ZodString>;
322
+ key: z.ZodNullable<z.ZodAny>;
323
+ value: z.ZodNullable<z.ZodAny>;
324
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
325
+ }, "strip", z.ZodTypeAny, {
326
+ id?: string | undefined;
327
+ key?: any;
328
+ value?: any;
329
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
330
+ }, {
331
+ id?: string | undefined;
332
+ key?: any;
333
+ value?: any;
334
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
335
+ }>, "many">;
336
+ }, z.ZodTypeAny, "passthrough">>;
337
+ get: (args_0: string, ...args: unknown[]) => Promise<z.objectOutputType<{
338
+ _id: z.ZodString;
339
+ _rev: z.ZodOptional<z.ZodString>;
340
+ }, z.ZodTypeAny, "passthrough"> | null>;
341
+ patch: (args_0: string, args_1: Record<string, any>, ...args: unknown[]) => Promise<{
342
+ statusCode: number;
343
+ ok?: boolean | undefined;
344
+ error?: string | undefined;
345
+ id?: string | undefined;
346
+ rev?: string | undefined;
347
+ }>;
348
+ put: (args_0: z.objectInputType<{
349
+ _id: z.ZodString;
350
+ _rev: z.ZodOptional<z.ZodString>;
351
+ }, z.ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<{
352
+ statusCode: number;
353
+ ok?: boolean | undefined;
354
+ error?: string | undefined;
355
+ id?: string | undefined;
356
+ rev?: string | undefined;
357
+ }>;
358
+ bulkGet: (args_0: string[], ...args: unknown[]) => Promise<z.objectOutputType<{
359
+ _id: z.ZodString;
360
+ _rev: z.ZodOptional<z.ZodString>;
361
+ }, z.ZodTypeAny, "passthrough">[]>;
362
+ bulkSave: (args_0: z.objectInputType<{
363
+ _id: z.ZodString;
364
+ }, z.ZodTypeAny, "passthrough">[], ...args: unknown[]) => Promise<{
365
+ ok?: boolean | null | undefined;
366
+ id?: string | null | undefined;
367
+ rev?: string | null | undefined;
368
+ error?: string | null | undefined;
369
+ reason?: string | null | undefined;
370
+ }[]>;
371
+ queryStream: (args_0: string, args_1: {
372
+ startkey?: any;
373
+ endkey?: any;
374
+ descending?: boolean | undefined;
375
+ skip?: number | undefined;
376
+ limit?: number | undefined;
377
+ key?: any;
378
+ include_docs?: boolean | undefined;
379
+ reduce?: boolean | undefined;
380
+ group?: boolean | undefined;
381
+ group_level?: number | undefined;
382
+ } | undefined, args_2: (args_0: {
383
+ id?: string | undefined;
384
+ key?: any;
385
+ value?: any;
386
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
387
+ }, ...args: unknown[]) => unknown, ...args: unknown[]) => Promise<undefined>;
388
+ }, {
389
+ query: (args_0: string, args_1: {
390
+ startkey?: any;
391
+ endkey?: any;
392
+ descending?: boolean | undefined;
393
+ skip?: number | undefined;
394
+ limit?: number | undefined;
395
+ key?: any;
396
+ include_docs?: boolean | undefined;
397
+ reduce?: boolean | undefined;
398
+ group?: boolean | undefined;
399
+ group_level?: number | undefined;
400
+ } | undefined, ...args: unknown[]) => Promise<z.objectInputType<{
401
+ error: z.ZodOptional<z.ZodString>;
402
+ rows: z.ZodArray<z.ZodObject<{
403
+ id: z.ZodOptional<z.ZodString>;
404
+ key: z.ZodNullable<z.ZodAny>;
405
+ value: z.ZodNullable<z.ZodAny>;
406
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
407
+ }, "strip", z.ZodTypeAny, {
408
+ id?: string | undefined;
409
+ key?: any;
410
+ value?: any;
411
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
412
+ }, {
413
+ id?: string | undefined;
414
+ key?: any;
415
+ value?: any;
416
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
417
+ }>, "many">;
418
+ }, z.ZodTypeAny, "passthrough">>;
419
+ get: (args_0: string, ...args: unknown[]) => Promise<z.objectInputType<{
420
+ _id: z.ZodString;
421
+ _rev: z.ZodOptional<z.ZodString>;
422
+ }, z.ZodTypeAny, "passthrough"> | null>;
423
+ patch: (args_0: string, args_1: Record<string, any>, ...args: unknown[]) => Promise<{
424
+ statusCode: number;
425
+ ok?: boolean | undefined;
426
+ error?: string | undefined;
427
+ id?: string | undefined;
428
+ rev?: string | undefined;
429
+ }>;
430
+ put: (args_0: z.objectOutputType<{
431
+ _id: z.ZodString;
432
+ _rev: z.ZodOptional<z.ZodString>;
433
+ }, z.ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<{
434
+ statusCode: number;
435
+ ok?: boolean | undefined;
436
+ error?: string | undefined;
437
+ id?: string | undefined;
438
+ rev?: string | undefined;
439
+ }>;
440
+ bulkGet: (args_0: string[], ...args: unknown[]) => Promise<z.objectInputType<{
441
+ _id: z.ZodString;
442
+ _rev: z.ZodOptional<z.ZodString>;
443
+ }, z.ZodTypeAny, "passthrough">[]>;
444
+ bulkSave: (args_0: z.objectOutputType<{
445
+ _id: z.ZodString;
446
+ }, z.ZodTypeAny, "passthrough">[], ...args: unknown[]) => Promise<{
447
+ ok?: boolean | null | undefined;
448
+ id?: string | null | undefined;
449
+ rev?: string | null | undefined;
450
+ error?: string | null | undefined;
451
+ reason?: string | null | undefined;
452
+ }[]>;
453
+ queryStream: (args_0: string, args_1: {
454
+ startkey?: any;
455
+ endkey?: any;
456
+ descending?: boolean | undefined;
457
+ skip?: number | undefined;
458
+ limit?: number | undefined;
459
+ key?: any;
460
+ include_docs?: boolean | undefined;
461
+ reduce?: boolean | undefined;
462
+ group?: boolean | undefined;
463
+ group_level?: number | undefined;
464
+ } | undefined, args_2: (args_0: {
465
+ id?: string | undefined;
466
+ key?: any;
467
+ value?: any;
468
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
469
+ }, ...args: unknown[]) => unknown, ...args: unknown[]) => Promise<undefined>;
470
+ }>>;
471
+ export type BindSchema = z.infer<typeof Bind>;
472
+ import { z } from 'zod';
473
+ //# sourceMappingURL=bind.d.mts.map
package/schema/bind.d.mts.map ADDED
@@ -0,0 +1 @@
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"}