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

package/types/output/impl/utils/mergeNeedleOpts.d.mts

@@ -0,0 +1,53 @@
+export declare const mergeNeedleOpts: (args_0: {
+    couch: string;
+    backoffFactor?: number | undefined;
+    bindWithRetry?: boolean | undefined;
+    initialDelay?: number | undefined;
+    logger?: import("zod/v4/core").$InferInnerFunctionType<import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodVoid> | {
+        error?: import("zod/v4/core").$InferInnerFunctionType<import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodVoid> | undefined;
+        warn?: import("zod/v4/core").$InferInnerFunctionType<import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodVoid> | undefined;
+        info?: import("zod/v4/core").$InferInnerFunctionType<import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodVoid> | undefined;
+        debug?: import("zod/v4/core").$InferInnerFunctionType<import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodVoid> | undefined;
+    } | undefined;
+    maxRetries?: number | undefined;
+    needleOpts?: {
+        json?: boolean | undefined;
+        compressed?: boolean | undefined;
+        follow_max?: number | undefined;
+        follow_set_cookie?: boolean | undefined;
+        follow_set_referer?: boolean | undefined;
+        follow?: number | undefined;
+        timeout?: number | undefined;
+        read_timeout?: number | undefined;
+        parse_response?: boolean | undefined;
+        decode?: boolean | undefined;
+        parse_cookies?: boolean | undefined;
+        cookies?: Record<string, string> | undefined;
+        headers?: Record<string, string> | undefined;
+        auth?: "auto" | "digest" | "basic" | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        proxy?: string | undefined;
+        agent?: any;
+        rejectUnauthorized?: boolean | undefined;
+        output?: string | undefined;
+        parse?: boolean | undefined;
+        multipart?: boolean | undefined;
+        open_timeout?: number | undefined;
+        response_timeout?: number | undefined;
+        keepAlive?: boolean | undefined;
+    } | undefined;
+    throwOnGetNotFound?: boolean | undefined;
+    useConsoleLogger?: boolean | undefined;
+    '~emitter'?: any;
+    '~normalizedLogger'?: any;
+}, args_1: {
+    json: boolean;
+    headers: Record<string, string>;
+    parse_response?: boolean | undefined;
+}) => {
+    json: boolean;
+    headers: Record<string, string>;
+    parse_response?: boolean | undefined;
+};
+//# sourceMappingURL=mergeNeedleOpts.d.mts.map

package/types/output/impl/utils/mergeNeedleOpts.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeNeedleOpts.d.mts","sourceRoot":"","sources":["../../../../impl/utils/mergeNeedleOpts.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa1B,CAAA"}

package/types/output/impl/utils/parseRows.d.mts

@@ -0,0 +1,15 @@
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts';
+export type OnInvalidDocAction = 'throw' | 'skip';
+export declare function parseRows<DocSchema extends StandardSchemaV1 = StandardSchemaV1<any>, KeySchema extends StandardSchemaV1 = StandardSchemaV1<any>, ValueSchema extends StandardSchemaV1 = StandardSchemaV1<any>>(rows: unknown, options: {
+    onInvalidDoc?: OnInvalidDocAction;
+    docSchema?: DocSchema;
+    keySchema?: KeySchema;
+    valueSchema?: ValueSchema;
+}): Promise<{
+    id?: string;
+    key?: StandardSchemaV1.InferOutput<KeySchema>;
+    value?: StandardSchemaV1.InferOutput<ValueSchema>;
+    doc?: StandardSchemaV1.InferOutput<DocSchema>;
+    error?: string;
+}[]>;
+//# sourceMappingURL=parseRows.d.mts.map

package/types/output/impl/utils/parseRows.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRows.d.mts","sourceRoot":"","sources":["../../../../impl/utils/parseRows.mts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAGtE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,CAAA;AAEjD,wBAAsB,SAAS,CAC7B,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,GAAG,CAAC,EAC1D,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,GAAG,CAAC,EAC1D,WAAW,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,GAAG,CAAC,EAE5D,IAAI,EAAE,OAAO,EACb,OAAO,EAAE;IACP,YAAY,CAAC,EAAE,kBAAkB,CAAA;IACjC,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;SAOM,MAAM;UACL,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;YACrC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC;UAC3C,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;YACrC,MAAM;KAuFjB"}

package/types/output/impl/utils/parseRows.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseRows.test.d.mts.map

package/types/output/impl/utils/parseRows.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRows.test.d.mts","sourceRoot":"","sources":["../../../../impl/utils/parseRows.test.mts"],"names":[],"mappings":""}

package/types/output/impl/utils/queryBuilder.d.mts

@@ -0,0 +1,68 @@
+import type { ViewOptions } from '../../schema/couch/couch.input.schema.ts';
+/**
+ * A builder class for constructing CouchDB view query options.
+ * Provides a fluent API for setting various query parameters.
+ * @example
+ * const queryOptions = new QueryBuilder()
+ *   .limit(10)
+ *   .include_docs()
+ *   .startKey('someKey')
+ *   .build();
+ * @see SimpleViewOptions for the full list of options.
+ *
+ * @remarks
+ * Each method corresponds to a CouchDB view option and returns the builder instance for chaining.
+ *
+ * @returns The constructed SimpleViewOptions object.
+ */
+export declare class QueryBuilder {
+    #private;
+    descending(descending?: boolean): this;
+    endkey_docid(endkeyDocId: NonNullable<ViewOptions['endkey_docid']>): this;
+    /**
+     * Alias for endkey_docid
+     */
+    end_key_doc_id(endkeyDocId: NonNullable<ViewOptions['endkey_docid']>): this;
+    endkey(endkey: ViewOptions['endkey']): this;
+    /**
+     * Alias for endkey
+     */
+    endKey(endkey: ViewOptions['endkey']): this;
+    /**
+     * Alias for endkey
+     */
+    end_key(endkey: ViewOptions['endkey']): this;
+    group(group?: boolean): this;
+    group_level(level: NonNullable<ViewOptions['group_level']>): this;
+    include_docs(includeDocs?: boolean): this;
+    inclusive_end(inclusiveEnd?: boolean): this;
+    key(key: ViewOptions['key']): this;
+    keys(keys: NonNullable<ViewOptions['keys']>): this;
+    limit(limit: NonNullable<ViewOptions['limit']>): this;
+    reduce(reduce?: boolean): this;
+    skip(skip: NonNullable<ViewOptions['skip']>): this;
+    sorted(sorted?: boolean): this;
+    stable(stable?: boolean): this;
+    startkey(startkey: ViewOptions['startkey']): this;
+    /**
+     * Alias for startkey
+     */
+    startKey(startkey: ViewOptions['startkey']): this;
+    /**
+     * Alias for startkey
+     */
+    start_key(startkey: ViewOptions['startkey']): this;
+    startkey_docid(startkeyDocId: NonNullable<ViewOptions['startkey_docid']>): this;
+    /**
+     * Alias for startkey_docid
+     */
+    start_key_doc_id(startkeyDocId: NonNullable<ViewOptions['startkey_docid']>): this;
+    update(update: NonNullable<ViewOptions['update']>): this;
+    update_seq(updateSeq?: boolean): this;
+    /**
+     * Builds and returns the ViewOptions object.
+     */
+    build(): ViewOptions;
+}
+export declare const createQuery: () => QueryBuilder;
+//# sourceMappingURL=queryBuilder.d.mts.map

package/types/output/impl/utils/queryBuilder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryBuilder.d.mts","sourceRoot":"","sources":["../../../../impl/utils/queryBuilder.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAA;AAE3E;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,YAAY;;IAGvB,UAAU,CAAC,UAAU,UAAO,GAAG,IAAI;IAKnC,YAAY,CAAC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI;IAKzE;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI;IAK3E,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI;IAK3C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI;IAK3C;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI;IAK5C,KAAK,CAAC,KAAK,UAAO,GAAG,IAAI;IAKzB,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,GAAG,IAAI;IAKjE,YAAY,CAAC,WAAW,UAAO,GAAG,IAAI;IAKtC,aAAa,CAAC,YAAY,UAAO,GAAG,IAAI;IAKxC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,IAAI;IAKlC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI;IAKlD,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAKrD,MAAM,CAAC,MAAM,UAAO,GAAG,IAAI;IAK3B,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI;IAKlD,MAAM,CAAC,MAAM,UAAO,GAAG,IAAI;IAK3B,MAAM,CAAC,MAAM,UAAO,GAAG,IAAI;IAK3B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI;IAKjD;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI;IAKjD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI;IAKlD,cAAc,CAAC,aAAa,EAAE,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,GAAG,IAAI;IAK/E;;OAEG;IACH,gBAAgB,CAAC,aAAa,EAAE,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,GAAG,IAAI;IAKjF,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI;IAKxD,UAAU,CAAC,SAAS,UAAO,GAAG,IAAI;IAKlC;;OAEG;IACH,KAAK,IAAI,WAAW;CAGrB;AAOD,eAAO,MAAM,WAAW,QAAO,YAAkC,CAAA"}

package/types/output/impl/utils/queryBuilder.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryBuilder.test.d.mts.map

package/types/output/impl/utils/queryBuilder.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryBuilder.test.d.mts","sourceRoot":"","sources":["../../../../impl/utils/queryBuilder.test.mts"],"names":[],"mappings":""}

package/types/output/impl/utils/queryString.d.mts

@@ -0,0 +1,9 @@
+import { ViewOptions } from '../../schema/couch/couch.input.schema.ts';
+/**
+ * Serialize CouchDB view options into a URL-safe query string, quoting values CouchDB expects as JSON.
+ * @param options The view options to serialize
+ * @param params The list of option keys that require JSON quoting
+ * @returns The serialized query string
+ */
+export declare function queryString(options?: ViewOptions): string;
+//# sourceMappingURL=queryString.d.mts.map

package/types/output/impl/utils/queryString.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryString.d.mts","sourceRoot":"","sources":["../../../../impl/utils/queryString.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAA;AAYtE;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,WAAgB,GAAG,MAAM,CAyB7D"}

package/types/output/impl/utils/queryString.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryString.test.d.mts.map

package/types/output/impl/utils/queryString.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryString.test.d.mts","sourceRoot":"","sources":["../../../../impl/utils/queryString.test.mts"],"names":[],"mappings":""}

package/types/output/impl/utils/trackedEmitter.d.mts

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

package/types/output/impl/utils/trackedEmitter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackedEmitter.d.mts","sourceRoot":"","sources":["../../../../impl/utils/trackedEmitter.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,qBAAa,cAAe,SAAQ,YAAY;gBAElC,OAAO,KAAA;IAKnB,IAAI,CAAC,KAAK,KAAA,EAAE,GAAG,IAAI,OAAA;CAkBpB;AAED,eAAO,MAAM,YAAY,GAAG,WAAM,QAGjC,CAAA"}

package/{impl → types/output/impl/utils}/transactionErrors.d.mts

@@ -1,29 +1,12 @@
-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 declare class TransactionSetupError extends Error {
+    details: Record<string, unknown>;
+    constructor(message: string, details?: Record<string, unknown>);
 }
-export class TransactionVersionConflictError extends Error {
-    /**
-     * @param {string[]} conflictingIds
-     */
-    constructor(conflictingIds: string[]);
+export declare class TransactionVersionConflictError extends Error {
     conflictingIds: string[];
+    constructor(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;
-    }>);
+export declare class TransactionBulkOperationError extends Error {
     failedDocs: {
         ok?: boolean | null;
         id?: string | null;
@@ -31,20 +14,15 @@ export class TransactionBulkOperationError extends Error {
         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<{
+    constructor(failedDocs: Array<{
         ok?: boolean | null;
         id?: string | null;
         rev?: string | null;
         error?: string | null;
         reason?: string | null;
     }>);
+}
+export declare class TransactionRollbackError extends Error {
     originalError: Error;
     rollbackResults: {
         ok?: boolean | null;
@@ -53,5 +31,12 @@ export class TransactionRollbackError extends Error {
         error?: string | null;
         reason?: string | null;
     }[];
+    constructor(message: string, originalError: Error, rollbackResults: Array<{
+        ok?: boolean | null;
+        id?: string | null;
+        rev?: string | null;
+        error?: string | null;
+        reason?: string | null;
+    }>);
 }
 //# sourceMappingURL=transactionErrors.d.mts.map

package/types/output/impl/utils/transactionErrors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionErrors.d.mts","sourceRoot":"","sources":["../../../../impl/utils/transactionErrors.mts"],"names":[],"mappings":"AAAA,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAEpB,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAKnE;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,cAAc,EAAE,MAAM,EAAE,CAAA;gBAEZ,cAAc,EAAE,MAAM,EAAE;CAKrC;AAED,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,UAAU,EAAE;QACV,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;QACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,EAAE,CAAA;gBAGD,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;QACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,CAAC;CAML;AAED,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,aAAa,EAAE,KAAK,CAAA;IACpB,eAAe,EAAE;QACf,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;QACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,EAAE,CAAA;gBAGD,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,KAAK,EACpB,eAAe,EAAE,KAAK,CAAC;QACrB,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;QACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,CAAC;CAOL"}

package/types/output/index.d.mts

@@ -0,0 +1,32 @@
+import { createQuery } from './impl/utils/queryBuilder.mts';
+import { QueryBuilder } from './impl/utils/queryBuilder.mts';
+import { bindConfig } from './impl/bindConfig.mts';
+import { withRetry } from './impl/retry.mts';
+import { bulkGet, bulkGetDictionary } from './impl/bulkGet.mts';
+import { getAtRev, get } from './impl/get.mts';
+import { queryStream } from './impl/stream.mts';
+import { patch, patchDangerously } from './impl/patch.mts';
+import { put } from './impl/put.mts';
+import { remove } from './impl/remove.mts';
+import { bulkSave, bulkSaveTransaction } from './impl/bulkSave.mts';
+import { query } from './impl/query.mts';
+import { getDBInfo } from './impl/getDBInfo.mts';
+import { bulkRemove, bulkRemoveMap } from './impl/bulkRemove.mts';
+import { createLock, removeLock } from './impl/sugar/lock.mts';
+import { watchDocs } from './impl/sugar/watch.mts';
+export { get, getAtRev, put, remove, bulkGet, bulkSave, query, queryStream, getDBInfo, patch, patchDangerously, bulkRemove, bulkRemoveMap, bulkGetDictionary, bulkSaveTransaction, watchDocs, bindConfig, withRetry, QueryBuilder, createQuery, createLock, removeLock };
+export type { BulkGetBound, BulkGetDictionaryBound, BulkGetDictionaryOptions, BulkGetDictionaryResult, BulkGetOptions, BulkGetResponse } from './impl/bulkGet.mts';
+export type { OnInvalidDocAction } from './impl/utils/parseRows.mts';
+export type { GetOptions, GetBound, GetAtRevBound } from './impl/get.mts';
+export type { QueryBound } from './impl/query.mts';
+export type { ViewString, ViewOptions as SimpleViewOptions } from './schema/couch/couch.input.schema.ts';
+export type { ViewRow, CouchDoc, CouchDocInput, ViewQueryResponse, ViewQueryResponseValidated, ViewRowValidated } from './schema/couch/couch.output.schema.ts';
+export type { RetryOptions } from './impl/retry.mts';
+export type { NetworkError, RetryableError, NotFoundError } from './impl/utils/errors.mts';
+export type { OnRow } from './impl/stream.mts';
+export type { CouchConfig, CouchConfigInput } from './schema/config.mts';
+export type { LockOptions, LockOptionsInput, LockDoc } from './schema/sugar/lock.mts';
+export type { WatchOptions as WatchOptionsSchema, WatchOptionsInput } from './schema/sugar/watch.mts';
+export type { BoundInstance } from './impl/bindConfig.mts';
+export type { StandardSchemaV1 } from './types/standard-schema.ts';
+//# sourceMappingURL=index.d.mts.map

package/types/output/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACnE,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD,OAAO,EACL,GAAG,EACH,QAAQ,EACR,GAAG,EACH,MAAM,EACN,OAAO,EACP,QAAQ,EACR,KAAK,EACL,WAAW,EACX,SAAS,EAGT,KAAK,EACL,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,SAAS,EAGT,UAAU,EACV,SAAS,EAGT,YAAY,EACZ,WAAW,EACX,UAAU,EACV,UAAU,EACX,CAAA;AAED,YAAY,EACV,YAAY,EACZ,sBAAsB,EACtB,wBAAwB,EACxB,uBAAuB,EACvB,cAAc,EACd,eAAe,EAChB,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AACpE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACzE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,YAAY,EACV,UAAU,EACV,WAAW,IAAI,iBAAiB,EACjC,MAAM,sCAAsC,CAAA;AAC7C,YAAY,EACV,OAAO,EACP,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,0BAA0B,EAC1B,gBAAgB,EACjB,MAAM,uCAAuC,CAAA;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC1F,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACxE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACrF,YAAY,EACV,YAAY,IAAI,kBAAkB,EAClC,iBAAiB,EAClB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA"}

package/types/output/index.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.mts.map

package/types/output/index.test.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.mts","sourceRoot":"","sources":["../../index.test.mts"],"names":[],"mappings":""}

package/types/output/schema/config.d.mts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import type { StandardSchemaV1 } from '../types/standard-schema.ts';
+export declare const NeedleBaseOptions: z.ZodObject<{
+    json: z.ZodBoolean;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    parse_response: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NeedleBaseOptionsSchema = z.infer<typeof NeedleBaseOptions>;
+export declare const NeedleOptions: z.ZodObject<{
+    json: z.ZodOptional<z.ZodBoolean>;
+    compressed: z.ZodOptional<z.ZodBoolean>;
+    follow_max: z.ZodOptional<z.ZodNumber>;
+    follow_set_cookie: z.ZodOptional<z.ZodBoolean>;
+    follow_set_referer: z.ZodOptional<z.ZodBoolean>;
+    follow: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    read_timeout: z.ZodOptional<z.ZodNumber>;
+    parse_response: z.ZodOptional<z.ZodBoolean>;
+    decode: z.ZodOptional<z.ZodBoolean>;
+    parse_cookies: z.ZodOptional<z.ZodBoolean>;
+    cookies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        digest: "digest";
+        basic: "basic";
+    }>>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    proxy: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodAny>;
+    rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodString>;
+    parse: z.ZodOptional<z.ZodBoolean>;
+    multipart: z.ZodOptional<z.ZodBoolean>;
+    open_timeout: z.ZodOptional<z.ZodNumber>;
+    response_timeout: z.ZodOptional<z.ZodNumber>;
+    keepAlive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const CouchConfig: z.ZodObject<{
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+    }, z.core.$strip>, z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>]>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    needleOpts: z.ZodOptional<z.ZodObject<{
+        json: z.ZodOptional<z.ZodBoolean>;
+        compressed: z.ZodOptional<z.ZodBoolean>;
+        follow_max: z.ZodOptional<z.ZodNumber>;
+        follow_set_cookie: z.ZodOptional<z.ZodBoolean>;
+        follow_set_referer: z.ZodOptional<z.ZodBoolean>;
+        follow: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        read_timeout: z.ZodOptional<z.ZodNumber>;
+        parse_response: z.ZodOptional<z.ZodBoolean>;
+        decode: z.ZodOptional<z.ZodBoolean>;
+        parse_cookies: z.ZodOptional<z.ZodBoolean>;
+        cookies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            digest: "digest";
+            basic: "basic";
+        }>>;
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        proxy: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodAny>;
+        rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+        output: z.ZodOptional<z.ZodString>;
+        parse: z.ZodOptional<z.ZodBoolean>;
+        multipart: z.ZodOptional<z.ZodBoolean>;
+        open_timeout: z.ZodOptional<z.ZodNumber>;
+        response_timeout: z.ZodOptional<z.ZodNumber>;
+        keepAlive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    '~emitter': z.ZodOptional<z.ZodAny>;
+    '~normalizedLogger': z.ZodOptional<z.ZodAny>;
+}, z.core.$strict>;
+export type CouchConfig = StandardSchemaV1.InferOutput<typeof CouchConfig>;
+export type CouchConfigInput = StandardSchemaV1.InferInput<typeof CouchConfig>;
+//# sourceMappingURL=config.d.mts.map

package/types/output/schema/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../../schema/config.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAanE,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEvE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BxB,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BY,CAAA;AAEpC,MAAM,MAAM,WAAW,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,WAAW,CAAC,CAAA;AAC1E,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/types/output/schema/couch/couch.input.schema.d.ts

@@ -0,0 +1,29 @@
+import z from 'zod';
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts';
+export type ViewString = '_all_docs' | `_design/${string}/_view/${string}`;
+export declare const ViewOptions: z.ZodObject<{
+    descending: z.ZodOptional<z.ZodBoolean>;
+    endkey_docid: z.ZodOptional<z.ZodString>;
+    endkey: z.ZodOptional<z.ZodAny>;
+    group_level: z.ZodOptional<z.ZodNumber>;
+    group: z.ZodOptional<z.ZodBoolean>;
+    include_docs: z.ZodOptional<z.ZodBoolean>;
+    inclusive_end: z.ZodOptional<z.ZodBoolean>;
+    key: z.ZodOptional<z.ZodAny>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    reduce: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    sorted: z.ZodOptional<z.ZodBoolean>;
+    stable: z.ZodOptional<z.ZodBoolean>;
+    startkey: z.ZodOptional<z.ZodAny>;
+    startkey_docid: z.ZodOptional<z.ZodString>;
+    update: z.ZodOptional<z.ZodEnum<{
+        lazy: "lazy";
+        true: "true";
+        false: "false";
+    }>>;
+    update_seq: z.ZodOptional<z.ZodBoolean>;
+}, z.z.core.$strip>;
+export type ViewOptions = StandardSchemaV1.InferOutput<typeof ViewOptions>;
+//# sourceMappingURL=couch.input.schema.d.ts.map

package/types/output/schema/couch/couch.input.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"couch.input.schema.d.ts","sourceRoot":"","sources":["../../../../schema/couch/couch.input.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,WAAW,MAAM,UAAU,MAAM,EAAE,CAAA;AAE1E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;mBAoC4B,CAAA;AACpD,MAAM,MAAM,WAAW,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/types/output/schema/couch/couch.output.schema.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts';
+/**
+ * Default schema for a returned CouchDB document if no validation schema is provided.
+ */
+export declare const CouchDoc: z.ZodObject<{
+    _id: z.ZodString;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type CouchDoc = StandardSchemaV1.InferOutput<typeof CouchDoc>;
+/**
+ * A type for input CouchDB documents (without required _id).
+ */
+export type CouchDocInput = Omit<CouchDoc, '_id'> & {
+    _id?: string;
+};
+/**
+ * Default schema for a CouchDB view row if no validation schema is provided.
+ */
+export declare const ViewRow: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    doc: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        _id: z.ZodString;
+        _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+        _deleted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ViewRow = StandardSchemaV1.InferOutput<typeof ViewRow>;
+/**
+ * A CouchDB view row with validated key, value, and document schemas.
+ */
+export type ViewRowValidated<DocSchema extends StandardSchemaV1, KeySchema extends StandardSchemaV1, ValueSchema extends StandardSchemaV1> = {
+    id?: string;
+    key?: StandardSchemaV1.InferOutput<KeySchema>;
+    value?: StandardSchemaV1.InferOutput<ValueSchema>;
+    doc?: StandardSchemaV1.InferOutput<DocSchema>;
+    error?: string;
+};
+/**
+ * Response type for a CouchDB view query if no validation schemas are provided.
+ */
+export declare const ViewQueryResponse: z.ZodObject<{
+    total_rows: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    rows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        doc: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            _id: z.ZodString;
+            _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            _deleted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    update_seq: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ViewQueryResponse = StandardSchemaV1.InferOutput<typeof ViewQueryResponse>;
+/**
+ * Response type for a CouchDB view query with validated key, value, and document schemas.
+ */
+export type ViewQueryResponseValidated<DocSchema extends StandardSchemaV1, KeySchema extends StandardSchemaV1 = StandardSchemaV1<unknown>, ValueSchema extends StandardSchemaV1 = StandardSchemaV1<unknown>> = Omit<ViewQueryResponse, 'rows'> & {
+    rows: Array<ViewRowValidated<DocSchema, KeySchema, ValueSchema>>;
+};
+/**
+ * CouchDB _bulk_docs response schema
+ */
+export declare const BulkSaveResponse: z.ZodArray<z.ZodObject<{
+    ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>>;
+export type BulkSaveResponse = z.infer<typeof BulkSaveResponse>;
+export declare const CouchPutResponse: 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>;
+}, z.core.$strip>;
+export declare const CouchDBInfo: z.ZodObject<{
+    cluster: z.ZodOptional<z.ZodObject<{
+        n: z.ZodOptional<z.ZodNumber>;
+        q: z.ZodOptional<z.ZodNumber>;
+        r: z.ZodOptional<z.ZodNumber>;
+        w: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    compact_running: z.ZodOptional<z.ZodBoolean>;
+    db_name: z.ZodString;
+    disk_format_version: z.ZodOptional<z.ZodNumber>;
+    doc_count: z.ZodOptional<z.ZodNumber>;
+    doc_del_count: z.ZodOptional<z.ZodNumber>;
+    instance_start_time: z.ZodOptional<z.ZodString>;
+    purge_seq: z.ZodOptional<z.ZodString>;
+    sizes: z.ZodOptional<z.ZodObject<{
+        active: z.ZodOptional<z.ZodNumber>;
+        external: z.ZodOptional<z.ZodNumber>;
+        file: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    update_seq: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    props: z.ZodOptional<z.ZodObject<{
+        partitioned: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type CouchDBInfo = z.infer<typeof CouchDBInfo>;
+//# sourceMappingURL=couch.output.schema.d.ts.map

package/types/output/schema/couch/couch.output.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"couch.output.schema.d.ts","sourceRoot":"","sources":["../../../../schema/couch/couch.output.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;iBAInB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,QAAQ,CAAC,CAAA;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpE;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;iBAMlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,OAAO,CAAC,CAAA;AAElE;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,gBAAgB,EAClC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,gBAAgB,IAClC;IACF,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;IAC7C,KAAK,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,CAAA;IACjD,GAAG,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;iBAa5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEtF;;GAEG;AACH,MAAM,MAAM,0BAA0B,CACpC,SAAS,SAAS,gBAAgB,EAClC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,OAAO,CAAC,EAC9D,WAAW,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,OAAO,CAAC,IAC9D,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,GAAG;IACpC,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAA;CACjE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;kBAQ5B,CAAA;AACD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,gBAAgB;;;;;;iBAM3B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;iBAsEtB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/types/output/schema/sugar/lock.d.mts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts';
+export declare const LockDoc: z.ZodObject<{
+    _id: z.ZodString;
+    _rev: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    _deleted: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"lock">;
+    locks: z.ZodString;
+    lockedAt: z.ZodString;
+    lockedBy: z.ZodString;
+}, z.core.$loose>;
+export type LockDoc = StandardSchemaV1.InferOutput<typeof LockDoc>;
+export declare const LockOptions: z.ZodObject<{
+    enableLocking: z.ZodPrefault<z.ZodBoolean>;
+    username: z.ZodString;
+}, z.core.$strip>;
+export type LockOptions = StandardSchemaV1.InferOutput<typeof LockOptions>;
+export type LockOptionsInput = StandardSchemaV1.InferInput<typeof LockOptions>;
+//# sourceMappingURL=lock.d.mts.map

package/types/output/schema/sugar/lock.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.mts","sourceRoot":"","sources":["../../../../schema/sugar/lock.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,eAAO,MAAM,OAAO;;;;;;;;iBAKlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,OAAO,CAAC,CAAA;AAElE,eAAO,MAAM,WAAW;;;iBAGtB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,WAAW,CAAC,CAAA;AAC1E,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/types/output/schema/sugar/watch.d.mts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts';
+export declare const WatchOptions: z.ZodObject<{
+    include_docs: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    initialDelay: z.ZodOptional<z.ZodNumber>;
+    maxDelay: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WatchOptions = StandardSchemaV1.InferOutput<typeof WatchOptions>;
+export type WatchOptionsInput = StandardSchemaV1.InferInput<typeof WatchOptions>;
+//# sourceMappingURL=watch.d.mts.map

package/types/output/schema/sugar/watch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.mts","sourceRoot":"","sources":["../../../../schema/sugar/watch.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,eAAO,MAAM,YAAY;;;;;iBAOb,CAAA;AAEZ,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,CAAA;AAC5E,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA"}