hide-a-bed 5.0.2 → 5.0.3

package/cjs/schema/bulk.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bulk_exports = {};
+__export(bulk_exports, {
+  BulkGet: () => BulkGet,
+  BulkGetBound: () => BulkGetBound,
+  BulkGetDictionary: () => BulkGetDictionary,
+  BulkGetDictionaryBound: () => BulkGetDictionaryBound,
+  BulkGetDictionaryResponse: () => BulkGetDictionaryResponse,
+  BulkRemove: () => BulkRemove,
+  BulkRemoveBound: () => BulkRemoveBound,
+  BulkSave: () => BulkSave,
+  BulkSaveBound: () => BulkSaveBound,
+  BulkSaveResponseSchema: () => BulkSaveResponseSchema,
+  BulkSaveRow: () => BulkSaveRow,
+  BulkSaveTransaction: () => BulkSaveTransaction,
+  BulkSaveTransactionBound: () => BulkSaveTransactionBound
+});
+module.exports = __toCommonJS(bulk_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_query = require("./query.cjs");
+var import_crud = require("./crud.cjs");
+const BulkSaveRow = import_zod.z.object({
+  ok: import_zod.z.boolean().nullish(),
+  id: import_zod.z.string().nullish(),
+  rev: import_zod.z.string().nullish(),
+  error: import_zod.z.string().nullish().describe("if an error occured, one word reason, eg conflict"),
+  reason: import_zod.z.string().nullish().describe("a full error message")
+});
+const BulkSaveResponseSchema = import_zod.z.array(BulkSaveRow);
+const BulkSave = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkSaveBound = import_zod.z.function().args(
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkGet = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(import_query.SimpleViewQueryResponse));
+const BulkGetBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(import_query.SimpleViewQueryResponse));
+const BulkRemove = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkRemoveBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to delete"))
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkGetDictionaryResponse = import_zod.z.object({
+  found: import_zod.z.record(import_zod.z.string(), import_crud.CouchDoc),
+  notFound: import_zod.z.record(import_zod.z.string(), import_query.ViewRow)
+});
+const BulkGetDictionary = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(BulkGetDictionaryResponse));
+const BulkGetDictionaryBound = import_zod.z.function().args(
+  import_zod.z.array(import_zod.z.string().describe("the ids to get"))
+).returns(import_zod.z.promise(BulkGetDictionaryResponse));
+const BulkSaveTransaction = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("transaction id"),
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));
+const BulkSaveTransactionBound = import_zod.z.function().args(
+  import_zod.z.string().describe("transaction id"),
+  import_zod.z.array(import_crud.CouchDoc)
+).returns(import_zod.z.promise(BulkSaveResponseSchema));

package/cjs/schema/changes.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var changes_exports = {};
+__export(changes_exports, {
+  Changes: () => Changes,
+  ChangesBound: () => ChangesBound,
+  ChangesEmitter: () => ChangesEmitter,
+  ChangesOptions: () => ChangesOptions,
+  ChangesResponse: () => ChangesResponse
+});
+module.exports = __toCommonJS(changes_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_crud = require("./crud.cjs");
+const ChangesOptions = import_zod.z.object({
+  feed: import_zod.z.enum(["continuous", "longpoll"]).default("continuous"),
+  filter: import_zod.z.any(),
+  // z.union([z.string(), z.array()]).optional(),
+  inactivity_ms: import_zod.z.number().default(60 * 60 * 1e3),
+  /** @type {number} */
+  timeout: import_zod.z.number().optional(),
+  requestTimeout: import_zod.z.number().default(2 * 60 * 1e3),
+  since: import_zod.z.union([import_zod.z.number(), import_zod.z.literal("now")]).default(0),
+  heartbeat: import_zod.z.number().default(30 * 1e3),
+  style: import_zod.z.enum(["main_only", "all_docs"]).default("main_only"),
+  include_docs: import_zod.z.boolean().default(false),
+  query_params: import_zod.z.record(import_zod.z.any()).default({}),
+  use_post: import_zod.z.boolean().default(false)
+}).partial();
+const ChangesResponse = import_zod.z.object({
+  id: import_zod.z.string(),
+  seq: import_zod.z.number(),
+  changes: import_zod.z.array(import_zod.z.object({
+    rev: import_zod.z.string()
+  })),
+  doc: import_crud.CouchDoc.nullish().optional(),
+  deleted: import_zod.z.boolean().optional()
+});
+const ChangesEmitter = import_zod.z.object({
+  on: import_zod.z.function().args(import_zod.z.string(), import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void())).returns(import_zod.z.any()),
+  removeListener: import_zod.z.function().args(import_zod.z.string(), import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void())).returns(import_zod.z.any()),
+  stop: import_zod.z.function().returns(import_zod.z.void())
+});
+const Changes = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()),
+  ChangesOptions
+).returns(import_zod.z.promise(ChangesEmitter));
+const ChangesBound = import_zod.z.function().args(
+  import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()),
+  ChangesOptions
+).returns(import_zod.z.promise(ChangesEmitter));

package/cjs/schema/config.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  CouchConfig: () => CouchConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_zod = require("zod");
+const LoggerSchema = import_zod.z.object({
+  error: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  warn: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  info: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional(),
+  debug: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()).optional()
+}).or(import_zod.z.function().args(
+  import_zod.z.string(),
+  // level
+  import_zod.z.any()
+  // message/args
+).returns(import_zod.z.void()));
+const CouchConfig = import_zod.z.object({
+  throwOnGetNotFound: import_zod.z.boolean().optional().default(false).describe("if a get is 404 should we throw or return undefined"),
+  couch: import_zod.z.string().describe("the url of the couch db"),
+  bindWithRetry: import_zod.z.boolean().optional().default(true).describe("should we bind with retry"),
+  maxRetries: import_zod.z.number().optional().default(3).describe("maximum number of retry attempts"),
+  initialDelay: import_zod.z.number().optional().default(1e3).describe("initial retry delay in milliseconds"),
+  backoffFactor: import_zod.z.number().optional().default(2).describe("multiplier for exponential backoff"),
+  useConsoleLogger: import_zod.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: import_zod.z.any().optional()
+  // Internal property for caching normalized logger
+}).passthrough().describe("The std config object");

package/cjs/schema/crud.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var crud_exports = {};
+__export(crud_exports, {
+  CouchDoc: () => CouchDoc,
+  CouchDocResponse: () => CouchDocResponse,
+  CouchGet: () => CouchGet,
+  CouchGetAtRev: () => CouchGetAtRev,
+  CouchGetAtRevBound: () => CouchGetAtRevBound,
+  CouchGetBound: () => CouchGetBound,
+  CouchGetOptions: () => CouchGetOptions,
+  CouchGetWithOptions: () => CouchGetWithOptions,
+  CouchPut: () => CouchPut,
+  CouchPutBound: () => CouchPutBound
+});
+module.exports = __toCommonJS(crud_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+const CouchDoc = import_zod.z.object({
+  _id: import_zod.z.string().describe("the couch doc id"),
+  _rev: import_zod.z.string().optional().nullish().describe("the doc revision"),
+  _deleted: import_zod.z.boolean().optional().describe("is the doc deleted")
+}).passthrough();
+const CouchDocResponse = import_zod.z.object({
+  ok: import_zod.z.boolean().optional().describe("did the request succeed"),
+  error: import_zod.z.string().optional().describe("the error message, if did not succed"),
+  statusCode: import_zod.z.number(),
+  id: import_zod.z.string().optional().describe("the couch doc id"),
+  rev: import_zod.z.string().optional().describe("the new rev of the doc")
+});
+const CouchPut = import_zod.z.function().args(
+  import_config.CouchConfig,
+  CouchDoc
+).returns(import_zod.z.promise(CouchDocResponse));
+const CouchPutBound = import_zod.z.function().args(
+  CouchDoc
+).returns(import_zod.z.promise(CouchDocResponse));
+const CouchGet = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetAtRev = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  import_zod.z.string().describe("the rev")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetAtRevBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id"),
+  import_zod.z.string().describe("the rev")
+).returns(import_zod.z.promise(CouchDoc.nullable()));
+const CouchGetOptions = import_zod.z.object({
+  rev: import_zod.z.string().optional().describe("the couch doc revision")
+});
+const CouchGetWithOptions = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  CouchGetOptions
+).returns(import_zod.z.promise(CouchDoc.nullable()));

package/cjs/schema/patch.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var patch_exports = {};
+__export(patch_exports, {
+  Patch: () => Patch,
+  PatchBound: () => PatchBound,
+  PatchDangerously: () => PatchDangerously,
+  PatchDangerouslyBound: () => PatchDangerouslyBound,
+  PatchProperties: () => PatchProperties,
+  StrictPatchProperties: () => StrictPatchProperties
+});
+module.exports = __toCommonJS(patch_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_crud = require("./crud.cjs");
+const PatchProperties = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
+const StrictPatchProperties = import_zod.z.object({
+  _rev: import_zod.z.string()
+}).and(PatchProperties);
+const Patch = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  StrictPatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id"),
+  StrictPatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchDangerously = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the couch doc id"),
+  PatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));
+const PatchDangerouslyBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the couch doc id"),
+  PatchProperties
+).returns(import_zod.z.promise(import_crud.CouchDocResponse));

package/cjs/schema/query.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_exports = {};
+__export(query_exports, {
+  SimpleViewOptions: () => SimpleViewOptions,
+  SimpleViewQuery: () => SimpleViewQuery,
+  SimpleViewQueryBound: () => SimpleViewQueryBound,
+  SimpleViewQueryResponse: () => SimpleViewQueryResponse,
+  ViewRow: () => ViewRow
+});
+module.exports = __toCommonJS(query_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+const ViewRow = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  key: import_zod.z.any().nullable(),
+  value: import_zod.z.any().nullable(),
+  doc: import_zod.z.object({}).passthrough().optional().nullish(),
+  error: import_zod.z.string().optional().describe("usually not_found, if something is wrong with this doc")
+});
+const SimpleViewQueryResponse = import_zod.z.object({
+  error: import_zod.z.string().optional().describe("if something is wrong"),
+  rows: import_zod.z.array(ViewRow)
+}).passthrough();
+const SimpleViewOptions = import_zod.z.object({
+  startkey: import_zod.z.any().optional(),
+  endkey: import_zod.z.any().optional(),
+  descending: import_zod.z.boolean().optional().describe("sort results descending"),
+  skip: import_zod.z.number().positive().optional().describe("skip this many rows"),
+  limit: import_zod.z.number().positive().optional().describe("limit the results to this many rows"),
+  key: import_zod.z.any().optional(),
+  keys: import_zod.z.array(import_zod.z.any()).optional(),
+  include_docs: import_zod.z.boolean().optional().describe("join the id to the doc and return it"),
+  reduce: import_zod.z.boolean().optional().describe("reduce the results"),
+  group: import_zod.z.boolean().optional().describe("group the results"),
+  group_level: import_zod.z.number().positive().optional().describe("group the results at this level")
+}).optional().describe("query options");
+const SimpleViewQuery = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the view name"),
+  SimpleViewOptions
+).returns(import_zod.z.promise(SimpleViewQueryResponse));
+const SimpleViewQueryBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the view name"),
+  SimpleViewOptions
+).returns(import_zod.z.promise(SimpleViewQueryResponse));

package/cjs/schema/stream.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_exports = {};
+__export(stream_exports, {
+  OnRow: () => OnRow,
+  SimpleViewQueryStream: () => SimpleViewQueryStream,
+  SimpleViewQueryStreamBound: () => SimpleViewQueryStreamBound
+});
+module.exports = __toCommonJS(stream_exports);
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_query = require("./query.cjs");
+const OnRow = import_zod.z.function().args(
+  import_query.ViewRow
+);
+const SimpleViewQueryStream = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("the view name"),
+  import_query.SimpleViewOptions,
+  OnRow
+).returns(import_zod.z.promise(import_zod.z.undefined()));
+const SimpleViewQueryStreamBound = import_zod.z.function().args(
+  import_zod.z.string().describe("the view name"),
+  import_query.SimpleViewOptions,
+  OnRow
+).returns(import_zod.z.promise(import_zod.z.undefined()));

package/cjs/schema/sugar/lock.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lock_exports = {};
+__export(lock_exports, {
+  CreateLock: () => CreateLock,
+  CreateLockBound: () => CreateLockBound,
+  Lock: () => Lock,
+  LockOptions: () => LockOptions,
+  RemoveLock: () => RemoveLock,
+  RemoveLockBound: () => RemoveLockBound
+});
+module.exports = __toCommonJS(lock_exports);
+var import_zod = require("zod");
+var import_config = require("../config.cjs");
+var import_crud = require("../crud.cjs");
+const Lock = import_crud.CouchDoc.extend({
+  type: import_zod.z.literal("lock"),
+  locks: import_zod.z.string().describe("the document ID being locked"),
+  lockedAt: import_zod.z.string().describe("ISO timestamp when lock was created"),
+  lockedBy: import_zod.z.string().describe("username of who created the lock")
+});
+const LockOptions = import_zod.z.object({
+  enableLocking: import_zod.z.boolean().default(true).describe("whether locking is enabled"),
+  username: import_zod.z.string().describe("username to attribute locks to")
+});
+const CreateLock = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("document ID to lock"),
+  LockOptions
+).returns(import_zod.z.promise(import_zod.z.boolean()));
+const CreateLockBound = import_zod.z.function().args(
+  import_zod.z.string().describe("document ID to lock"),
+  LockOptions
+).returns(import_zod.z.promise(import_zod.z.boolean()));
+const RemoveLock = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.string().describe("document ID to unlock"),
+  LockOptions
+).returns(import_zod.z.promise(import_zod.z.void()));
+const RemoveLockBound = import_zod.z.function().args(
+  import_zod.z.string().describe("document ID to unlock"),
+  LockOptions
+).returns(import_zod.z.promise(import_zod.z.void()));

package/cjs/schema/sugar/watch.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var watch_exports = {};
+__export(watch_exports, {
+  WatchDocs: () => WatchDocs,
+  WatchDocsBound: () => WatchDocsBound,
+  WatchOptions: () => WatchOptions
+});
+module.exports = __toCommonJS(watch_exports);
+var import_zod = require("zod");
+var import_config = require("../config.cjs");
+var import_changes = require("../changes.cjs");
+const WatchOptions = import_zod.z.object({
+  include_docs: import_zod.z.boolean().default(false)
+}).partial();
+const WatchDocs = import_zod.z.function().args(
+  import_config.CouchConfig,
+  import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]),
+  import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()),
+  WatchOptions
+).returns(import_changes.ChangesEmitter);
+const WatchDocsBound = import_zod.z.function().args(
+  import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]),
+  import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.void()),
+  WatchOptions
+).returns(import_changes.ChangesEmitter);

package/impl/bulk.d.mts

@@ -0,0 +1,11 @@
+/** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
+export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
+/** @type { import('../schema/bulk.mjs').BulkGetSchema } */
+export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
+/** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
+export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
+/** @type { import('../schema/bulk.mjs').BulkGetDictionarySchema } */
+export const bulkGetDictionary: import("../schema/bulk.mjs").BulkGetDictionarySchema;
+/** @type { import('../schema/bulk.mjs').BulkSaveTransactionSchema } bulkSaveTransaction */
+export const bulkSaveTransaction: import("../schema/bulk.mjs").BulkSaveTransactionSchema;
+//# sourceMappingURL=bulk.d.mts.map

package/impl/bulk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAkBA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAsCrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CA8BpD;AAIF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAkBvD;AAEF,qEAAqE;AACrE,gCADY,OAAO,oBAAoB,EAAE,uBAAuB,CAwB9D;AAEF,2FAA2F;AAC3F,kCADY,OAAO,oBAAoB,EAAE,yBAAyB,CAiJhE"}

package/impl/changes.d.mts

@@ -0,0 +1,12 @@
+/** @type { import('../schema/changes.mjs').ChangesSchema } */
+export const changes: import("../schema/changes.mjs").ChangesSchema;
+export type ChangeInfo = {
+    seq: string | number;
+    id: string;
+    changes: Array<{
+        rev: string;
+    }>;
+    deleted?: boolean;
+    doc?: any;
+};
+//# sourceMappingURL=changes.d.mts.map

package/impl/changes.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changes.d.mts","sourceRoot":"","sources":["changes.mjs"],"names":[],"mappings":"AAeA,8DAA8D;AAC9D,sBADY,OAAO,uBAAuB,EAAE,aAAa,CAqCvD;yBA/CY;IACT,GAAG,EAAE,MAAM,GAAC,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,GAAG,CAAA;CACV"}

package/impl/crud.d.mts

@@ -0,0 +1,7 @@
+/** @type { import('../schema/crud.mjs').CouchGetSchema } */
+export const get: import("../schema/crud.mjs").CouchGetSchema;
+/** @type { import('../schema/crud.mjs').CouchGetAtRevSchema } */
+export const getAtRev: import("../schema/crud.mjs").CouchGetAtRevSchema;
+/** @type { import('../schema/crud.mjs').CouchPutSchema } */
+export const put: import("../schema/crud.mjs").CouchPutSchema;
+//# sourceMappingURL=crud.d.mts.map

package/impl/crud.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAqDA,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAIrD;AAEF,iEAAiE;AACjE,uBADY,OAAO,oBAAoB,EAAE,mBAAmB,CAI1D;AAEF,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAqCrD"}

package/impl/errors.d.mts

@@ -0,0 +1,43 @@
+/**
+ * @typedef {Object} NetworkError
+ * @property {string} code - The error code
+ * @property {string} [message] - Optional error message
+ */
+export class NotFoundError extends Error {
+    /**
+     * @param {string} docId - The ID of the document that wasn't found
+     * @param {string} [message] - Optional error message
+     */
+    constructor(docId: string, message?: string | undefined);
+    docId: string;
+}
+export class RetryableError extends Error {
+    /**
+     * @param {number|undefined} statusCode - The HTTP status code to check
+     * @returns {boolean} Whether the status code is retryable
+     */
+    static isRetryableStatusCode(statusCode: number | undefined): boolean;
+    /**
+     * @param {NetworkError | unknown} err - The network error to handle
+     * @throws {RetryableError} If the error is retryable
+     * @throws {Error} If the error is not retryable
+     */
+    static handleNetworkError(err: NetworkError | unknown): void;
+    /**
+     * @param {string} message - The error message
+     * @param {number|undefined} statusCode - The HTTP status code
+     */
+    constructor(message: string, statusCode: number | undefined);
+    statusCode: number | undefined;
+}
+export type NetworkError = {
+    /**
+     * - The error code
+     */
+    code: string;
+    /**
+     * - Optional error message
+     */
+    message?: string | undefined;
+};
+//# sourceMappingURL=errors.d.mts.map

package/impl/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","sourceRoot":"","sources":["errors.mjs"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IACE;;;OAGG;IACH,mBAHW,MAAM,gCAOhB;IADC,cAAkB;CAErB;AAED;IAWE;;;OAGG;IACH,yCAHW,MAAM,GAAC,SAAS,GACd,OAAO,CAKnB;IAED;;;;OAIG;IACH,+BAJW,YAAY,GAAG,OAAO,QAsBhC;IA1CD;;;OAGG;IACH,qBAHW,MAAM,cACN,MAAM,GAAC,SAAS,EAM1B;IADC,+BAA4B;CAoC/B;;;;;UA5Da,MAAM"}