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

package/schema/couch/couch.input.schema.ts

@@ -0,0 +1,43 @@
+import z from 'zod'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+export type ViewString = '_all_docs' | `_design/${string}/_view/${string}`
+
+export const ViewOptions = z
+  .object({
+    descending: z.boolean().optional().describe('sort results descending'),
+    endkey_docid: z
+      .string()
+      .optional()
+      .describe('stop returning records when this document ID is reached'),
+    endkey: z.any().optional(),
+    group_level: z.number().positive().optional().describe('group the results at this level'),
+    group: z.boolean().optional().describe('group the results'),
+    include_docs: z.boolean().optional().describe('join the id to the doc and return it'),
+    inclusive_end: z
+      .boolean()
+      .optional()
+      .describe('whether the endkey is included in the result, default true'),
+    key: z.any().optional(),
+    keys: z.array(z.any()).optional(),
+    limit: z.number().nonnegative().optional().describe('limit the results to this many rows'),
+    reduce: z.boolean().optional().describe('reduce the results'),
+    skip: z.number().nonnegative().optional().describe('skip this many rows'),
+    sorted: z.boolean().optional().describe('sort returned rows, default true'),
+    stable: z
+      .boolean()
+      .optional()
+      .describe('ensure the view index is not updated during the query, default false'),
+    startkey: z.any().optional(),
+    startkey_docid: z
+      .string()
+      .optional()
+      .describe('start returning records when this document ID is reached'),
+    update: z
+      .enum(['true', 'false', 'lazy'])
+      .optional()
+      .describe('whether to update the view index before returning results, default true'),
+    update_seq: z.boolean().optional().describe('include the update sequence in the result')
+  })
+  .describe('base options for a CouchDB view query')
+export type ViewOptions = StandardSchemaV1.InferOutput<typeof ViewOptions>

package/schema/couch/couch.output.schema.ts

@@ -0,0 +1,169 @@
+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 const CouchDoc = z.looseObject({
+  _id: z.string().describe('the couch doc id'),
+  _rev: z.string().optional().nullish().describe('the doc revision'),
+  _deleted: z.boolean().optional().describe('is the doc deleted')
+})
+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 const ViewRow = z.object({
+  id: z.string().optional(),
+  key: z.any().nullish(),
+  value: z.any().nullish(),
+  doc: CouchDoc.nullish(),
+  error: z.string().optional().describe('usually not_found, if something is wrong with this doc')
+})
+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 const ViewQueryResponse = z.object({
+  total_rows: z.number().nonnegative().optional().describe('total rows in the view'),
+  offset: z
+    .number()
+    .nonnegative()
+    .optional()
+    .describe('the offset of the first row in this result set'),
+  error: z.string().optional().describe('if something is wrong'),
+  rows: z.array(ViewRow).optional().describe('the rows returned by the view'),
+  update_seq: z
+    .number()
+    .optional()
+    .describe('the update sequence of the database at the time of the query')
+})
+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 const BulkSaveResponse = z.array(
+  z.object({
+    ok: z.boolean().nullish(),
+    id: z.string().nullish(),
+    rev: z.string().nullish(),
+    error: z.string().nullish().describe('if an error occurred, one word reason, eg conflict'),
+    reason: z.string().nullish().describe('a full error message')
+  })
+)
+export type BulkSaveResponse = z.infer<typeof BulkSaveResponse>
+
+export const CouchPutResponse = z.object({
+  ok: z.boolean().optional().describe('did the request succeed'),
+  error: z.string().optional().describe('the error message, if did not succeed'),
+  statusCode: z.number(),
+  id: z.string().optional().describe('the couch doc id'),
+  rev: z.string().optional().describe('the new rev of the doc')
+})
+
+export const CouchDBInfo = z.looseObject({
+  cluster: z
+    .object({
+      n: z.number().describe('Replicas. The number of copies of every document.').optional(),
+      q: z.number().describe('Shards. The number of range partitions.').optional(),
+      r: z
+        .number()
+        .describe(
+          'Read quorum. The number of consistent copies of a document that need to be read before a successful reply.'
+        )
+        .optional(),
+      w: z
+        .number()
+        .describe(
+          'Write quorum. The number of copies of a document that need to be written before a successful reply.'
+        )
+        .optional()
+    })
+    .optional(),
+  compact_running: z
+    .boolean()
+    .describe('Set to true if the database compaction routine is operating on this database.')
+    .optional(),
+  db_name: z.string().describe('The name of the database.'),
+  disk_format_version: z
+    .number()
+    .describe('The version of the physical format used for the data when it is stored on disk.')
+    .optional(),
+  doc_count: z.number().describe('A count of the documents in the specified database.').optional(),
+  doc_del_count: z.number().describe('Number of deleted documents').optional(),
+  instance_start_time: z.string().optional(),
+  purge_seq: z
+    .string()
+    .describe(
+      'An opaque string that describes the purge state of the database. Do not rely on this string for counting the number of purge operations.'
+    )
+    .optional(),
+  sizes: z
+    .object({
+      active: z
+        .number()
+        .describe('The size of live data inside the database, in bytes.')
+        .optional(),
+      external: z
+        .number()
+        .describe('The uncompressed size of database contents in bytes.')
+        .optional(),
+      file: z
+        .number()
+        .describe(
+          'The size of the database file on disk in bytes. Views indexes are not included in the calculation.'
+        )
+        .optional()
+    })
+    .optional(),
+  update_seq: z
+    .string()
+    .or(z.number())
+    .describe(
+      'An opaque string that describes the state of the database. Do not rely on this string for counting the number of updates.'
+    )
+    .optional(),
+  props: z
+    .object({
+      partitioned: z
+        .boolean()
+        .describe('If present and true, this indicates that the database is partitioned.')
+        .optional()
+    })
+    .optional()
+})
+export type CouchDBInfo = z.infer<typeof CouchDBInfo>

package/schema/sugar/lock.mts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { CouchDoc } from '../couch/couch.output.schema.ts'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+export const LockDoc = CouchDoc.extend({
+  type: z.literal('lock'),
+  locks: z.string().describe('the document ID being locked'),
+  lockedAt: z.string().describe('ISO timestamp when lock was created'),
+  lockedBy: z.string().describe('username of who created the lock')
+})
+export type LockDoc = StandardSchemaV1.InferOutput<typeof LockDoc>
+
+export const LockOptions = z.object({
+  enableLocking: z.boolean().prefault(true).describe('whether locking is enabled'),
+  username: z.string().describe('username to attribute locks to')
+})
+export type LockOptions = StandardSchemaV1.InferOutput<typeof LockOptions>
+export type LockOptionsInput = StandardSchemaV1.InferInput<typeof LockOptions>

package/schema/sugar/watch.mts

@@ -0,0 +1,14 @@
+import { z } from 'zod'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+export const WatchOptions = z
+  .object({
+    include_docs: z.boolean().default(false),
+    maxRetries: z.number().describe('maximum number of retries before giving up'),
+    initialDelay: z.number().describe('initial delay between retries in milliseconds'),
+    maxDelay: z.number().describe('maximum delay between retries in milliseconds')
+  })
+  .partial()
+
+export type WatchOptions = StandardSchemaV1.InferOutput<typeof WatchOptions>
+export type WatchOptionsInput = StandardSchemaV1.InferInput<typeof WatchOptions>

package/schema/util.mts

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+import { CouchConfig, NeedleBaseOptions, NeedleOptions } from './config.mts'
+
+export const MergeNeedleOpts = z.function({
+  input: [CouchConfig, NeedleBaseOptions],
+  output: NeedleOptions
+})
+export type MergeNeedleOptsSchema = z.infer<typeof MergeNeedleOpts>

package/tsconfig.json

@@ -1,13 +1,19 @@
 {
-  "include": ["*.mjs"],
+  "exclude": ["node_modules", "dist", "types/output", "docs"],
   "compilerOptions": {
-    "module": "Node16",
-    "target": "es2020",
+    "module": "nodenext",
+    "target": "esnext",
+    "erasableSyntaxOnly": true,
+    "rewriteRelativeImportExtensions": true,
+    "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "strict": true,
     "allowJs": true,
+    "checkJs": true,
+    "skipLibCheck": true,
     "declaration": true,
     "emitDeclarationOnly": true,
-    "declarationMap": true
+    "declarationMap": true,
+    "outDir": "types/output"
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig([
+  {
+    entry: 'index.mts',
+    outDir: 'dist/esm',
+    dts: false,
+    format: 'esm'
+  },
+  {
+    entry: 'index.mts',
+    outDir: 'dist/cjs',
+    dts: false,
+    format: 'cjs'
+  }
+])

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "exclude": ["**/dist/**"],
+  "kindSortOrder": ["Variable", "Function"]
+}

package/types/output/eslint.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("eslint/config").Config[];
+export default _default;
+//# sourceMappingURL=eslint.config.d.ts.map

package/types/output/eslint.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint.config.d.ts","sourceRoot":"","sources":["../../eslint.config.js"],"names":[],"mappings":""}

package/types/output/impl/bindConfig.d.mts

@@ -0,0 +1,174 @@
+import type z from 'zod';
+import { CouchConfig, type CouchConfigInput } from '../schema/config.mts';
+import { type BulkGetBound, type BulkGetDictionaryBound } from './bulkGet.mts';
+import { type GetBound, type GetAtRevBound } from './get.mts';
+import type { QueryBound } from './query.mts';
+export type BoundInstance = ReturnType<typeof doBind> & {
+    options(overrides: Partial<z.input<typeof CouchConfig>>): BoundInstance;
+};
+/**
+ * Build a validated binding that exposes CouchDB helpers plus an options() helper for overrides.
+ * @param config The CouchDB configuration
+ * @returns A bound instance with CouchDB operations and an options() method for overrides
+ */
+export declare const bindConfig: (config: CouchConfigInput) => BoundInstance;
+/**
+ * @internal
+ *
+ * Helper to bind a function to a config, optionally wrapping it with retry logic.
+ * Casts to the appropriate bound function type.
+ * @param func The function to bind
+ * @param config The CouchDB configuration
+ * @returns The bound function, possibly wrapped with retry logic
+ */
+export declare function getBoundWithRetry<TBound extends (...args: any[]) => Promise<any>>(func: (config: CouchConfig, ...args: any[]) => Promise<any>, config: CouchConfig): TBound;
+/**
+ * @internal
+ *
+ * Bind core CouchDB operations to a specific configuration, optionally applying retry wrappers.
+ * @param config The CouchDB configuration
+ * @returns An object with CouchDB operations bound to the provided configuration
+ */
+declare function doBind(config: CouchConfig): {
+    /**
+     * These functions use overloaded signatures when bound.
+     * To preserve the overloads we need dedicated Bound types
+     */
+    bulkGet: BulkGetBound;
+    bulkGetDictionary: BulkGetDictionaryBound;
+    get: GetBound;
+    getAtRev: GetAtRevBound;
+    query: QueryBound;
+    /**
+     * These functions have single signatures and can be bound directly
+     */
+    bulkRemove: (ids: string[]) => Promise<{
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }[]>;
+    bulkRemoveMap: (ids: string[]) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }[]>;
+    bulkSave: (docs: import("../index.mts").CouchDocInput[]) => Promise<{
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }[]>;
+    bulkSaveTransaction: (transactionId: string, docs: import("../index.mts").CouchDocInput[]) => Promise<{
+        ok?: boolean | null | undefined;
+        id?: string | null | undefined;
+        rev?: string | null | undefined;
+        error?: string | null | undefined;
+        reason?: string | null | undefined;
+    }[]>;
+    getDBInfo: () => Promise<{
+        [x: string]: unknown;
+        db_name: string;
+        cluster?: {
+            n?: number | undefined;
+            q?: number | undefined;
+            r?: number | undefined;
+            w?: number | undefined;
+        } | undefined;
+        compact_running?: boolean | undefined;
+        disk_format_version?: number | undefined;
+        doc_count?: number | undefined;
+        doc_del_count?: number | undefined;
+        instance_start_time?: string | undefined;
+        purge_seq?: string | undefined;
+        sizes?: {
+            active?: number | undefined;
+            external?: number | undefined;
+            file?: number | undefined;
+        } | undefined;
+        update_seq?: string | number | undefined;
+        props?: {
+            partitioned?: boolean | undefined;
+        } | undefined;
+    }>;
+    patch: (id: string, _properties: {
+        [x: string]: unknown;
+        _rev: string;
+    }) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    patchDangerously: (id: string, properties: Record<string, unknown>) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    } | undefined>;
+    put: (doc: {
+        [x: string]: unknown;
+        _id: string;
+        _rev?: string | null | undefined;
+        _deleted?: boolean | undefined;
+    }) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    queryStream: (view: string, options: {
+        descending?: boolean | undefined;
+        endkey_docid?: string | undefined;
+        endkey?: any;
+        group_level?: number | undefined;
+        group?: boolean | undefined;
+        include_docs?: boolean | undefined;
+        inclusive_end?: boolean | undefined;
+        key?: any;
+        keys?: any[] | undefined;
+        limit?: number | undefined;
+        reduce?: boolean | undefined;
+        skip?: number | undefined;
+        sorted?: boolean | undefined;
+        stable?: boolean | undefined;
+        startkey?: any;
+        startkey_docid?: string | undefined;
+        update?: "lazy" | "true" | "false" | undefined;
+        update_seq?: boolean | undefined;
+    } | undefined, onRow: import("./stream.mts").OnRow) => Promise<void>;
+    remove: (id: string, rev: string) => Promise<{
+        statusCode: number;
+        ok?: boolean | undefined;
+        error?: string | undefined;
+        id?: string | undefined;
+        rev?: string | undefined;
+    }>;
+    createLock: (docId: string, lockOptions: {
+        enableLocking: boolean;
+        username: string;
+    }) => Promise<boolean>;
+    removeLock: (docId: string, lockOptions: {
+        enableLocking: boolean;
+        username: string;
+    }) => Promise<void>;
+    watchDocs: (docIds: string | string[], onChange: (change: any) => void, optionsInput?: {
+        include_docs?: boolean | undefined;
+        maxRetries?: number | undefined;
+        initialDelay?: number | undefined;
+        maxDelay?: number | undefined;
+    } | undefined) => {
+        on: (event: string, listener: EventListener) => import("events")<[never]>;
+        removeListener: (event: string, listener: EventListener) => import("events")<[never]>;
+        stop: () => void;
+    };
+};
+export {};
+//# sourceMappingURL=bindConfig.d.mts.map

package/types/output/impl/bindConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindConfig.d.mts","sourceRoot":"","sources":["../../../impl/bindConfig.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEzE,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,sBAAsB,EAE5B,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAiB,MAAM,WAAW,CAAA;AAI5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAS7C,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,GAAG;IACtD,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC,GAAG,aAAa,CAAA;CACxE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,gBAAgB,KAAG,aAcrD,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAE/B,MAAM,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAG/C,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC3D,MAAM,EAAE,WAAW,UAYpB;AAED;;;;;;GAMG;AACH,iBAAS,MAAM,CAAC,MAAM,EAAE,WAAW;IAU/B;;;OAGG;;;;;;IAOH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCN"}

package/types/output/impl/bulkGet.d.mts

@@ -0,0 +1,75 @@
+import { type CouchConfigInput } from '../schema/config.mts';
+import { ViewQueryResponse, type ViewQueryResponseValidated, CouchDoc, type ViewRowValidated } from '../schema/couch/couch.output.schema.ts';
+import type { StandardSchemaV1 } from '../types/standard-schema.ts';
+import { type OnInvalidDocAction } from './utils/parseRows.mts';
+export type BulkGetResponse<DocSchema extends StandardSchemaV1 = StandardSchemaV1<CouchDoc>> = ViewQueryResponseValidated<DocSchema, StandardSchemaV1, StandardSchemaV1<{
+    rev: string;
+}>>;
+export type BulkGetOptions<DocSchema extends StandardSchemaV1> = {
+    includeDocs?: boolean;
+    validate?: {
+        docSchema: DocSchema;
+        onInvalidDoc?: OnInvalidDocAction;
+    };
+};
+/**
+ * Bulk get documents by IDs.
+ *
+ * @remarks
+ * By default, documents are included in the response. To exclude documents, set `includeDocs` to `false`.
+ * When `includeDocs` is `true`, you can provide a schema (StandardSchemaV1) to validate the documents.
+ * When a schema is provided, you can specify how to handle invalid documents using `onInvalidDoc` option.
+ * `onInvalidDoc` can be set to `'throw'` (default) to throw an error on invalid documents, or `'skip'` to omit them from the results.
+ *
+ * @template DocSchema - schema (StandardSchemaV1) used to validate each returned document, if provided.
+ *
+ * @param config - CouchDB configuration data that is validated before use.
+ * @param ids - Array of document IDs to retrieve.
+ * @param options - Options for bulk get operation, including whether to include documents and validation schema.
+ *
+ * @returns The bulk get response with rows optionally validated against the supplied document schema.
+ *
+ * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
+ * @throws {Error<StandardSchemaV1.FailureResult["issues"]>} When the configuration or validation schemas fail to parse.
+ * @throws {Error} When CouchDB returns a non-retryable error payload.
+ */
+export declare function bulkGet<DocSchema extends StandardSchemaV1 = typeof CouchDoc>(config: CouchConfigInput, ids: Array<string | undefined>, options?: BulkGetOptions<DocSchema>): Promise<BulkGetResponse<DocSchema>>;
+/**
+ * Bound version of bulkGet with config pre-applied.
+ */
+export type BulkGetBound = {
+    (ids: string[], options?: {
+        includeDocs?: boolean;
+    }): Promise<ViewQueryResponse>;
+    <DocSchema extends StandardSchemaV1>(ids: string[], options?: BulkGetOptions<DocSchema>): Promise<ViewQueryResponseValidated<DocSchema>>;
+};
+/**
+ * Bulk get documents by IDs and return a dictionary of found and not found documents.
+ */
+export type BulkGetDictionaryOptions<DocSchema extends StandardSchemaV1 = typeof CouchDoc> = Omit<BulkGetOptions<DocSchema>, 'includeDocs'>;
+export type BulkGetDictionaryResult<DocSchema extends StandardSchemaV1 = StandardSchemaV1<CouchDoc>> = {
+    found: Record<string, StandardSchemaV1.InferOutput<DocSchema>>;
+    notFound: Record<string, ViewRowValidated<DocSchema, StandardSchemaV1, StandardSchemaV1<{
+        rev: string;
+    }>>>;
+};
+/**
+ * Bulk get documents by IDs and return a dictionary of found and not found documents.
+ *
+ * @template DocSchema - Schema used to validate each returned document, if provided. Note: if a document is found and it fails validation this will throw a Error<StandardSchemaV1.FailureResult["issues"]>.
+ *
+ * @param config - CouchDB configuration data that is validated before use.
+ * @param ids - Array of document IDs to retrieve.
+ * @param options - Options for bulk get operation, including validation schema.
+ *
+ * @returns An object containing found documents and not found rows.
+ *
+ * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
+ * @throws {Error<StandardSchemaV1.FailureResult["issues"]>} When the configuration or validation schemas fail to parse.
+ * @throws {Error} When CouchDB returns a non-retryable error payload.
+ */
+export declare function bulkGetDictionary<DocSchema extends StandardSchemaV1 = typeof CouchDoc>(config: CouchConfigInput, ids: Array<string | undefined>, options?: Omit<BulkGetDictionaryOptions<DocSchema>, 'includeDocs'>): Promise<BulkGetDictionaryResult<DocSchema>>;
+export type BulkGetDictionaryBound = {
+    <DocSchema extends StandardSchemaV1 = typeof CouchDoc>(ids: string[], options: BulkGetDictionaryOptions<DocSchema>): Promise<BulkGetDictionaryResult<DocSchema>>;
+};
+//# sourceMappingURL=bulkGet.d.mts.map

package/types/output/impl/bulkGet.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkGet.d.mts","sourceRoot":"","sources":["../../../impl/bulkGet.mts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAIzE,OAAO,EACL,iBAAiB,EACjB,KAAK,0BAA0B,EAC/B,QAAQ,EACR,KAAK,gBAAgB,EACtB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,EAAa,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAE1E,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,QAAQ,CAAC,IACzF,0BAA0B,CACxB,SAAS,EACT,gBAAgB,EAChB,gBAAgB,CAAC;IACf,GAAG,EAAE,MAAM,CAAA;CACZ,CAAC,CACH,CAAA;AAEH,MAAM,MAAM,cAAc,CAAC,SAAS,SAAS,gBAAgB,IAAI;IAC/D,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,EAAE;QACT,SAAS,EAAE,SAAS,CAAA;QACpB,YAAY,CAAC,EAAE,kBAAkB,CAAA;KAClC,CAAA;CACF,CAAA;AAmGD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,OAAO,CAAC,SAAS,SAAS,gBAAgB,GAAG,OAAO,QAAQ,EAChF,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,EAC9B,OAAO,GAAE,cAAc,CAAC,SAAS,CAAM,uCAMxC;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,CACE,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,OAAO,CAAA;KACtB,GACA,OAAO,CAAC,iBAAiB,CAAC,CAAA;IAC7B,CAAC,SAAS,SAAS,gBAAgB,EACjC,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,GAClC,OAAO,CAAC,0BAA0B,CAAC,SAAS,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;GAEG;AAEH,MAAM,MAAM,wBAAwB,CAAC,SAAS,SAAS,gBAAgB,GAAG,OAAO,QAAQ,IAAI,IAAI,CAC/F,cAAc,CAAC,SAAS,CAAC,EACzB,aAAa,CACd,CAAA;AAED,MAAM,MAAM,uBAAuB,CACjC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,QAAQ,CAAC,IAC7D;IACF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAA;IAC9D,QAAQ,EAAE,MAAM,CACd,MAAM,EACN,gBAAgB,CAAC,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CACjF,CAAA;CACF,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,SAAS,gBAAgB,GAAG,OAAO,QAAQ,EAC1F,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,EAC9B,OAAO,CAAC,EAAE,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,GACjE,OAAO,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC,CAkC7C;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,CAAC,SAAS,SAAS,gBAAgB,GAAG,OAAO,QAAQ,EACnD,GAAG,EAAE,MAAM,EAAE,EACb,OAAO,EAAE,wBAAwB,CAAC,SAAS,CAAC,GAC3C,OAAO,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC,CAAA;CAC/C,CAAA"}

package/types/output/impl/bulkGet.test.d.mts

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

package/types/output/impl/bulkGet.test.d.mts.map

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

package/types/output/impl/bulkRemove.d.mts

@@ -0,0 +1,63 @@
+import { type CouchConfigInput } from '../schema/config.mts';
+/**
+ * Removes multiple documents from a CouchDB database using the _bulk_docs endpoint.
+ * It first retrieves the documents by their IDs, marks them as deleted, and then
+ * sends them back to the database for deletion.
+ *
+ * See https://docs.couchdb.org/en/stable/api/database/bulk-api.html#post--db-_bulk_docs
+ *
+ * @param configInput - The CouchDB configuration input.
+ * @param ids - An array of document IDs to be removed.
+ * @returns A promise that resolves to an array of results from the bulk delete operation.
+ *
+ * @example
+ * ```ts
+ * const config: CouchConfigInput = {
+ *   couch: 'http://localhost:5984/mydb',
+ *   useConsoleLogger: true
+ * };
+ * const idsToRemove = ['doc1', 'doc2', 'doc3'];
+ * const results = await bulkRemove(config, idsToRemove);
+ * console.log(results);
+ * ```
+ *
+ * @throws Will throw an error if the provided configuration is invalid or if the bulk delete operation fails.
+ */
+export declare const bulkRemove: (configInput: CouchConfigInput, ids: string[]) => Promise<{
+    ok?: boolean | null | undefined;
+    id?: string | null | undefined;
+    rev?: string | null | undefined;
+    error?: string | null | undefined;
+    reason?: string | null | undefined;
+}[]>;
+/**
+ * Removes multiple documents from a CouchDB database by their IDs using individual delete operations.
+ * It first retrieves the documents to get their revision IDs, then deletes each document one by one.
+ *
+ * See https://docs.couchdb.org/en/stable/api/document/common.html#delete--db-docid
+ *
+ * @param configInput - The CouchDB configuration input.
+ * @param ids - An array of document IDs to be removed.
+ * @returns A promise that resolves to an array of results from the individual delete operations.
+ *
+ * @example
+ * ```ts
+ * const config: CouchConfigInput = {
+ *   couch: 'http://localhost:5984/mydb',
+ *   useConsoleLogger: true
+ * };
+ * const idsToRemove = ['doc1', 'doc2', 'doc3'];
+ * const results = await bulkRemoveMap(config, idsToRemove);
+ * console.log(results);
+ * ```
+ *
+ * @throws Will throw an error if the provided configuration is invalid or if any delete operation fails.
+ */
+export declare const bulkRemoveMap: (configInput: CouchConfigInput, ids: string[]) => Promise<{
+    statusCode: number;
+    ok?: boolean | undefined;
+    error?: string | undefined;
+    id?: string | undefined;
+    rev?: string | undefined;
+}[]>;
+//# sourceMappingURL=bulkRemove.d.mts.map

package/types/output/impl/bulkRemove.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkRemove.d.mts","sourceRoot":"","sources":["../../../impl/bulkRemove.mts"],"names":[],"mappings":"AAKA,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEzE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,GAAU,aAAa,gBAAgB,EAAE,KAAK,MAAM,EAAE;;;;;;IAmB5E,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,aAAa,GAAU,aAAa,gBAAgB,EAAE,KAAK,MAAM,EAAE;;;;;;IAsB/E,CAAA"}

package/types/output/impl/bulkRemove.test.d.mts

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

package/types/output/impl/bulkRemove.test.d.mts.map

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