@decaf-ts/for-couchdb 0.1.0 → 0.1.2

package/lib/esm/types.d.ts

@@ -315,6 +315,50 @@ export interface ServerScope {
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */
     session(): Promise<DatabaseSessionResponse>;
 }
+/** Fetch with POST _all_docs parameters.
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+export interface DocumentFetchParams {
+    conflicts?: boolean;
+    descending?: boolean;
+    end_key?: string;
+    end_key_doc_id?: string;
+    include_docs?: boolean;
+    inclusive_end?: boolean;
+    key?: string;
+    keys?: string | string[];
+    limit?: number;
+    skip?: number;
+    stale?: string;
+    start_key?: string;
+    start_key_doc_id?: string;
+    update_seq?: boolean;
+}
+/** Document fetch error */
+export interface DocumentLookupFailure {
+    key: string;
+    error: string;
+}
+/** Bulk API per-document response. */
+export interface DocumentResponseRowMeta {
+    id: string;
+    key: string;
+    value: {
+        rev: string;
+    };
+    error?: string;
+}
+/** Bulk API per-document response with document body. */
+export interface DocumentResponseRow<D> extends DocumentResponseRowMeta {
+    doc?: D & Document;
+}
+/** Fetch with POST _all_docs response
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+export interface DocumentFetchResponse<D> {
+    offset: number;
+    rows: Array<DocumentResponseRow<D> | DocumentLookupFailure>;
+    total_rows: number;
+    update_seq?: number | string;
+}
 /** Documents scope */
 export interface DocumentScope<D> {
     /** Initiates new session for specified user credentials by providing Cookie value.
@@ -350,6 +394,9 @@ export interface DocumentScope<D> {
     /** Create a Mango index.
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */
     createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;
+    /** Fetch a list of documents by _id with options.
+     * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+    fetch(docnames: BulkFetchDocsWrapper, params: DocumentFetchParams): Promise<DocumentFetchResponse<D>>;
     /** Run Mango query.
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */
     find(query: MangoQuery): Promise<MangoResponse<D>>;

package/lib/esm/types.js

@@ -1,3 +1,3 @@
 export {};
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/types.ts"],"names":[],"mappings":"","file":"types.js","sourcesContent":["/** Mango response.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoResponse<D> {\n  /** Array of documents matching the search.\n   *\n   * In each matching document, the fields specified in the fields part of the request body are listed, along with\n   * their values. */\n  docs: (D & { _id: string; _rev: string })[];\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Execution warnings */\n  warning?: string;\n\n  /** Basic execution statistics for a specific request. */\n  execution_stats?: MangoExecutionStats;\n}\n\n/** Mango execution stats.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics} */\nexport interface MangoExecutionStats {\n  /** Number of index keys examined. Currently always 0. */\n  total_keys_examined: number;\n\n  /** Number of documents fetched from the database / index.\n   *\n   * Equivalent to using include_docs = true in a view. */\n  total_docs_examined: number;\n\n  /** Number of documents fetched from the database using an out-of-band document fetch.\n   *\n   * This is only non-zero when read quorum > 1 is specified in the query parameters. */\n  total_quorum_docs_examined: number;\n\n  /** Number of results returned from the query. */\n  results_returned: number;\n\n  /** Total execution time in milliseconds as measured by the database. */\n  execution_time_ms: number;\n}\n\n/** Document insert response:\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n\n/** Mango create index response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexResponse {\n  /** Flag to show whether the index was created or one already exists.\n   *\n   * Can be “created” or “exists”. */\n  result: string;\n\n  /** Id of the design document the index was created in. */\n  id: string;\n\n  /** Name of the index created. */\n  name: string;\n}\n\n/** Document delete response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\nexport interface DocumentDestroyResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n/** Document get response:\n * @see docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetResponse {\n  /** Document ID. */\n  _id: string;\n\n  /** Revision MVCC token. */\n  _rev: string;\n\n  /** Deletion flag. Available if document was removed. */\n  _deleted?: boolean;\n\n  /** Attachment’s stubs. Available if document has any attachments. */\n  _attachments?: any;\n\n  /** List of conflicted revisions. Available if requested with conflicts=true query parameter. */\n  _conflicts?: any[];\n\n  /** List of deleted conflicted revisions. Available if requested with deleted_conflicts=true query parameter. */\n  _deleted_conflicts?: any[];\n\n  /** Document’s update sequence in current database. Available if requested with local_seq=true query parameter. */\n  _local_seq?: string;\n\n  /** List of objects with information about local revisions and their status.\n   *\n   * Available if requested with open_revs query parameter. */\n  _revs_info?: any[];\n\n  /** List of local revision tokens without.\n   *\n   * Available if requested with revs=true query parameter. */\n  _revisions?: any;\n}\n\nexport interface BulkModifyDocsWrapper {\n  docs: any[];\n}\n\nexport interface BulkFetchDocsWrapper {\n  keys: string[];\n}\n/** Bulk API response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_bulk_docs} */\nexport interface DocumentBulkResponse {\n  /** Document ID. Available in all cases */\n  id: string;\n\n  /** New document revision token. Available if document has saved without errors. */\n  rev?: string;\n\n  /** Error type. Available if response code is 4xx */\n  error?: string;\n\n  /** Error reason. Available if response code is 4xx */\n  reason?: string;\n}\n/** Mango create index parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexRequest {\n  /** JSON object describing the index to create */\n  index: {\n    /** Array of field names following the sort syntax. */\n    fields: SortOrder[];\n\n    /** A selector to apply to documents at indexing time, creating a partial index. */\n    partial_filter_selector?: MangoSelector;\n  };\n\n  /** Name of the design document in which the index will be created. */\n  ddoc?: string;\n\n  /** Name of the index. If no name is provided, a name will be generated automatically. */\n  name?: string;\n\n  /** Can be \"json\" or \"text\".\n   *\n   * @default \"json\" */\n  type?: \"json\" | \"text\";\n\n  /** This field sets whether the created index will be a partitioned or global index. */\n  partitioned?: boolean;\n}\n\nexport type MangoValue = number | string | Date | boolean | object | null;\nexport type MangoOperator =\n  | \"$lt\"\n  | \"$lte\"\n  | \"$eq\"\n  | \"$ne\"\n  | \"$gte\"\n  | \"$gt\"\n  | \"$exists\"\n  | \"$type\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$size\"\n  | \"$mod\"\n  | \"$regex\"\n  | \"$or\"\n  | \"$and\"\n  | \"$nor\"\n  | \"$not\"\n  | \"$all\"\n  | \"$allMatch\"\n  | \"$elemMatch\";\n/** Mango selector syntax.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax} */\nexport type MangoSelector = {\n  [K in MangoOperator | string]:\n    | MangoSelector\n    | MangoSelector[]\n    | MangoValue\n    | MangoValue[];\n};\n\n/** Mango sort syntax\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax} */\nexport type SortOrder = string | string[] | { [key: string]: \"asc\" | \"desc\" };\n\n/** Mango query syntax.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoQuery {\n  /** JSON object describing criteria used to select documents. */\n  selector: MangoSelector;\n\n  /** Maximum number of results returned. @default 25 */\n  limit?: number;\n\n  /** Skip the first 'n' results, where 'n' is the value specified. */\n  skip?: number;\n\n  /** JSON array following sort syntax. */\n  sort?: SortOrder[];\n\n  /** JSON array specifying which fields of each object should be returned.\n   *\n   * If it is omitted, the entire object is returned.\n   *\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */\n  fields?: string[];\n\n  /* Instruct a query to use a specific index.\n   *\n   * Specified either as \"<design_document>\" or [\"<design_document>\", \"<index_name>\"]. */\n  use_index?: string | [string, string];\n\n  /** Read quorum needed for the result.\n   *\n   * @default 1 */\n  r?: number;\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Whether to update the index prior to returning the result.\n   *\n   * @default true */\n  update?: boolean;\n\n  /** Whether or not the view results should be returned from a “stable” set of shards. */\n  stable?: boolean;\n\n  /** Combination of update = false and stable = true options.\n   *\n   * Possible options: \"ok\", false (default). */\n  stale?: \"ok\" | false;\n\n  /** Include execution statistics in the query response.\n   *\n   * Optional, default: false. */\n  execution_stats?: boolean;\n}\n\n/** Database authentication response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\nexport interface DatabaseAuthResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** Username */\n  name: string;\n\n  /** List of user roles */\n  roles: string[];\n}\n\n/** Database _session response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\nexport interface DatabaseSessionResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** User context for the current user */\n  userCtx: any;\n\n  /** Server authentication configuration */\n  info: any;\n}\n\n// -------------------------------------\n// Document\n// -------------------------------------\n\nexport interface MaybeIdentifiedDocument {\n  _id?: string;\n}\n\nexport interface IdentifiedDocument {\n  _id: string;\n}\n\nexport interface MaybeRevisionedDocument {\n  _rev?: string;\n}\n\nexport interface RevisionedDocument {\n  _rev: string;\n}\n\nexport interface MaybeDocument\n  extends MaybeIdentifiedDocument,\n    MaybeRevisionedDocument {}\n\nexport interface Document extends IdentifiedDocument, RevisionedDocument {}\n\n// -------------------------------------\n// View\n// -------------------------------------\n\nexport type DocumentInfer<D> = (doc: D & Document) => void;\nexport interface View<D> {\n  map?: string | DocumentInfer<D>;\n  reduce?: string | DocumentInfer<D>;\n}\n\nexport interface ViewDocument<D> extends IdentifiedDocument {\n  views: {\n    [name: string]: View<D>;\n  };\n}\n\n/** Document insert parameters.\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertParams {\n  /** Document ID */\n  docName?: string;\n\n  /** Document’s revision if updating an existing document. Alternative to If-Match header or document key. */\n  rev?: string;\n\n  /** Stores document in batch mode. */\n  batch?: \"ok\";\n\n  /** Prevents insertion of a conflicting document.\n   *\n   * If false, a well-formed `_rev` must be included in the document. `new_edits=false` is used by the replicator to\n   * insert documents into the target database even if that leads to the creation of conflicts.\n   *\n   * @default true */\n  new_edits?: boolean;\n}\n\n/** Document get parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetParams {\n  /** Includes attachments bodies in response.\n   *\n   * @default false */\n  attachments?: boolean;\n\n  /** Includes encoding information in attachment stubs if the particular attachment is compressed.\n   *\n   * @default false */\n  att_encoding_info?: boolean;\n\n  /** Includes attachments only since specified revisions.\n   *\n   * Doesn’t includes attachments for specified revisions. */\n  atts_since?: any[];\n\n  /** Includes information about conflicts in document.\n   *\n   * @default false */\n  conflicts?: boolean;\n\n  /** Includes information about deleted conflicted revisions.\n   *\n   * @default false */\n  deleted_conflicts?: boolean;\n\n  /** Forces retrieving latest “leaf” revision, no matter what rev was requested.\n   *\n   * @default false */\n  latest?: boolean;\n\n  /** Includes last update sequence for the document.\n   *\n   * @default false */\n  local_seq?: boolean;\n\n  /** Acts same as specifying all conflicts, deleted_conflicts and revs_info query parameters.\n   *\n   * @default false */\n  meta?: boolean;\n\n  /** Retrieves documents of specified leaf revisions.\n   *\n   * Additionally, it accepts value as all to return all leaf revisions. */\n  open_revs?: any[];\n\n  /** Retrieves document of specified revision. */\n  rev?: string;\n\n  /** Includes list of all known document revisions. */\n  revs?: boolean;\n\n  /** Includes detailed information for all known document revisions.\n   *\n   * @default false */\n  revs_info?: boolean;\n}\n\n/** Server scope */\nexport interface ServerScope {\n  /**\n   * Returns a database object that allows you to perform operations against that database.\n   * @see README: {@link https://www.npmjs.com/package/nano#nanousename}\n   */\n  use<D>(db: string): DocumentScope<D>;\n  /**\n   * Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /**\n   * Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n}\n\n/** Documents scope */\nexport interface DocumentScope<D> {\n  /** Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /** Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n  /** Insert a document into this database.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument)\n  ): Promise<DocumentInsertResponse>;\n  /**\n   * Insert a document into this database with options.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument),\n    params: DocumentInsertParams | string | null\n  ): Promise<DocumentInsertResponse>;\n  /** Fetch a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(docname: string): Promise<DocumentGetResponse & D>;\n  /** Fetch a document from this database with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(\n    docname: string,\n    params?: DocumentGetParams\n  ): Promise<DocumentGetResponse & D>;\n  /** Delete a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\n  destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;\n  /** Bulk insert/update/delete multiple documents in this database.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(docs: BulkModifyDocsWrapper): Promise<DocumentBulkResponse[]>;\n  /** Bulk insert/update/delete multiple documents in this database, with options.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(\n    docs: BulkModifyDocsWrapper,\n    params: any\n  ): Promise<DocumentInsertResponse[]>;\n  /** Create a Mango index.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\n  createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;\n\n  /** Run Mango query.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */\n  find(query: MangoQuery): Promise<MangoResponse<D>>;\n  /** Server scope */\n  server: ServerScope;\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/types.ts"],"names":[],"mappings":"","file":"types.js","sourcesContent":["/** Mango response.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoResponse<D> {\n  /** Array of documents matching the search.\n   *\n   * In each matching document, the fields specified in the fields part of the request body are listed, along with\n   * their values. */\n  docs: (D & { _id: string; _rev: string })[];\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Execution warnings */\n  warning?: string;\n\n  /** Basic execution statistics for a specific request. */\n  execution_stats?: MangoExecutionStats;\n}\n\n/** Mango execution stats.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics} */\nexport interface MangoExecutionStats {\n  /** Number of index keys examined. Currently always 0. */\n  total_keys_examined: number;\n\n  /** Number of documents fetched from the database / index.\n   *\n   * Equivalent to using include_docs = true in a view. */\n  total_docs_examined: number;\n\n  /** Number of documents fetched from the database using an out-of-band document fetch.\n   *\n   * This is only non-zero when read quorum > 1 is specified in the query parameters. */\n  total_quorum_docs_examined: number;\n\n  /** Number of results returned from the query. */\n  results_returned: number;\n\n  /** Total execution time in milliseconds as measured by the database. */\n  execution_time_ms: number;\n}\n\n/** Document insert response:\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n\n/** Mango create index response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexResponse {\n  /** Flag to show whether the index was created or one already exists.\n   *\n   * Can be “created” or “exists”. */\n  result: string;\n\n  /** Id of the design document the index was created in. */\n  id: string;\n\n  /** Name of the index created. */\n  name: string;\n}\n\n/** Document delete response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\nexport interface DocumentDestroyResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n/** Document get response:\n * @see docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetResponse {\n  /** Document ID. */\n  _id: string;\n\n  /** Revision MVCC token. */\n  _rev: string;\n\n  /** Deletion flag. Available if document was removed. */\n  _deleted?: boolean;\n\n  /** Attachment’s stubs. Available if document has any attachments. */\n  _attachments?: any;\n\n  /** List of conflicted revisions. Available if requested with conflicts=true query parameter. */\n  _conflicts?: any[];\n\n  /** List of deleted conflicted revisions. Available if requested with deleted_conflicts=true query parameter. */\n  _deleted_conflicts?: any[];\n\n  /** Document’s update sequence in current database. Available if requested with local_seq=true query parameter. */\n  _local_seq?: string;\n\n  /** List of objects with information about local revisions and their status.\n   *\n   * Available if requested with open_revs query parameter. */\n  _revs_info?: any[];\n\n  /** List of local revision tokens without.\n   *\n   * Available if requested with revs=true query parameter. */\n  _revisions?: any;\n}\n\nexport interface BulkModifyDocsWrapper {\n  docs: any[];\n}\n\nexport interface BulkFetchDocsWrapper {\n  keys: string[];\n}\n/** Bulk API response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_bulk_docs} */\nexport interface DocumentBulkResponse {\n  /** Document ID. Available in all cases */\n  id: string;\n\n  /** New document revision token. Available if document has saved without errors. */\n  rev?: string;\n\n  /** Error type. Available if response code is 4xx */\n  error?: string;\n\n  /** Error reason. Available if response code is 4xx */\n  reason?: string;\n}\n/** Mango create index parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexRequest {\n  /** JSON object describing the index to create */\n  index: {\n    /** Array of field names following the sort syntax. */\n    fields: SortOrder[];\n\n    /** A selector to apply to documents at indexing time, creating a partial index. */\n    partial_filter_selector?: MangoSelector;\n  };\n\n  /** Name of the design document in which the index will be created. */\n  ddoc?: string;\n\n  /** Name of the index. If no name is provided, a name will be generated automatically. */\n  name?: string;\n\n  /** Can be \"json\" or \"text\".\n   *\n   * @default \"json\" */\n  type?: \"json\" | \"text\";\n\n  /** This field sets whether the created index will be a partitioned or global index. */\n  partitioned?: boolean;\n}\n\nexport type MangoValue = number | string | Date | boolean | object | null;\nexport type MangoOperator =\n  | \"$lt\"\n  | \"$lte\"\n  | \"$eq\"\n  | \"$ne\"\n  | \"$gte\"\n  | \"$gt\"\n  | \"$exists\"\n  | \"$type\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$size\"\n  | \"$mod\"\n  | \"$regex\"\n  | \"$or\"\n  | \"$and\"\n  | \"$nor\"\n  | \"$not\"\n  | \"$all\"\n  | \"$allMatch\"\n  | \"$elemMatch\";\n/** Mango selector syntax.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax} */\nexport type MangoSelector = {\n  [K in MangoOperator | string]:\n    | MangoSelector\n    | MangoSelector[]\n    | MangoValue\n    | MangoValue[];\n};\n\n/** Mango sort syntax\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax} */\nexport type SortOrder = string | string[] | { [key: string]: \"asc\" | \"desc\" };\n\n/** Mango query syntax.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoQuery {\n  /** JSON object describing criteria used to select documents. */\n  selector: MangoSelector;\n\n  /** Maximum number of results returned. @default 25 */\n  limit?: number;\n\n  /** Skip the first 'n' results, where 'n' is the value specified. */\n  skip?: number;\n\n  /** JSON array following sort syntax. */\n  sort?: SortOrder[];\n\n  /** JSON array specifying which fields of each object should be returned.\n   *\n   * If it is omitted, the entire object is returned.\n   *\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */\n  fields?: string[];\n\n  /* Instruct a query to use a specific index.\n   *\n   * Specified either as \"<design_document>\" or [\"<design_document>\", \"<index_name>\"]. */\n  use_index?: string | [string, string];\n\n  /** Read quorum needed for the result.\n   *\n   * @default 1 */\n  r?: number;\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Whether to update the index prior to returning the result.\n   *\n   * @default true */\n  update?: boolean;\n\n  /** Whether or not the view results should be returned from a “stable” set of shards. */\n  stable?: boolean;\n\n  /** Combination of update = false and stable = true options.\n   *\n   * Possible options: \"ok\", false (default). */\n  stale?: \"ok\" | false;\n\n  /** Include execution statistics in the query response.\n   *\n   * Optional, default: false. */\n  execution_stats?: boolean;\n}\n\n/** Database authentication response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\nexport interface DatabaseAuthResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** Username */\n  name: string;\n\n  /** List of user roles */\n  roles: string[];\n}\n\n/** Database _session response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\nexport interface DatabaseSessionResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** User context for the current user */\n  userCtx: any;\n\n  /** Server authentication configuration */\n  info: any;\n}\n\n// -------------------------------------\n// Document\n// -------------------------------------\n\nexport interface MaybeIdentifiedDocument {\n  _id?: string;\n}\n\nexport interface IdentifiedDocument {\n  _id: string;\n}\n\nexport interface MaybeRevisionedDocument {\n  _rev?: string;\n}\n\nexport interface RevisionedDocument {\n  _rev: string;\n}\n\nexport interface MaybeDocument\n  extends MaybeIdentifiedDocument,\n    MaybeRevisionedDocument {}\n\nexport interface Document extends IdentifiedDocument, RevisionedDocument {}\n\n// -------------------------------------\n// View\n// -------------------------------------\n\nexport type DocumentInfer<D> = (doc: D & Document) => void;\nexport interface View<D> {\n  map?: string | DocumentInfer<D>;\n  reduce?: string | DocumentInfer<D>;\n}\n\nexport interface ViewDocument<D> extends IdentifiedDocument {\n  views: {\n    [name: string]: View<D>;\n  };\n}\n\n/** Document insert parameters.\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertParams {\n  /** Document ID */\n  docName?: string;\n\n  /** Document’s revision if updating an existing document. Alternative to If-Match header or document key. */\n  rev?: string;\n\n  /** Stores document in batch mode. */\n  batch?: \"ok\";\n\n  /** Prevents insertion of a conflicting document.\n   *\n   * If false, a well-formed `_rev` must be included in the document. `new_edits=false` is used by the replicator to\n   * insert documents into the target database even if that leads to the creation of conflicts.\n   *\n   * @default true */\n  new_edits?: boolean;\n}\n\n/** Document get parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetParams {\n  /** Includes attachments bodies in response.\n   *\n   * @default false */\n  attachments?: boolean;\n\n  /** Includes encoding information in attachment stubs if the particular attachment is compressed.\n   *\n   * @default false */\n  att_encoding_info?: boolean;\n\n  /** Includes attachments only since specified revisions.\n   *\n   * Doesn’t includes attachments for specified revisions. */\n  atts_since?: any[];\n\n  /** Includes information about conflicts in document.\n   *\n   * @default false */\n  conflicts?: boolean;\n\n  /** Includes information about deleted conflicted revisions.\n   *\n   * @default false */\n  deleted_conflicts?: boolean;\n\n  /** Forces retrieving latest “leaf” revision, no matter what rev was requested.\n   *\n   * @default false */\n  latest?: boolean;\n\n  /** Includes last update sequence for the document.\n   *\n   * @default false */\n  local_seq?: boolean;\n\n  /** Acts same as specifying all conflicts, deleted_conflicts and revs_info query parameters.\n   *\n   * @default false */\n  meta?: boolean;\n\n  /** Retrieves documents of specified leaf revisions.\n   *\n   * Additionally, it accepts value as all to return all leaf revisions. */\n  open_revs?: any[];\n\n  /** Retrieves document of specified revision. */\n  rev?: string;\n\n  /** Includes list of all known document revisions. */\n  revs?: boolean;\n\n  /** Includes detailed information for all known document revisions.\n   *\n   * @default false */\n  revs_info?: boolean;\n}\n\n/** Server scope */\nexport interface ServerScope {\n  /**\n   * Returns a database object that allows you to perform operations against that database.\n   * @see README: {@link https://www.npmjs.com/package/nano#nanousename}\n   */\n  use<D>(db: string): DocumentScope<D>;\n  /**\n   * Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /**\n   * Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n}\n\n/** Fetch with POST _all_docs parameters.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\nexport interface DocumentFetchParams {\n  conflicts?: boolean;\n  descending?: boolean;\n  end_key?: string;\n  end_key_doc_id?: string;\n  include_docs?: boolean;\n  inclusive_end?: boolean;\n  key?: string;\n  keys?: string | string[];\n  limit?: number;\n  skip?: number;\n  stale?: string;\n  start_key?: string;\n  start_key_doc_id?: string;\n  update_seq?: boolean;\n}\n\n/** Document fetch error */\nexport interface DocumentLookupFailure {\n  key: string;\n  error: string;\n}\n/** Bulk API per-document response. */\nexport interface DocumentResponseRowMeta {\n  id: string;\n  key: string;\n  value: {\n    rev: string;\n  };\n  error?: string;\n}\n\n/** Bulk API per-document response with document body. */\nexport interface DocumentResponseRow<D> extends DocumentResponseRowMeta {\n  doc?: D & Document;\n}\n\n/** Fetch with POST _all_docs response\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\nexport interface DocumentFetchResponse<D> {\n  offset: number;\n  rows: Array<DocumentResponseRow<D> | DocumentLookupFailure>;\n  total_rows: number;\n  update_seq?: number | string;\n}\n\n/** Documents scope */\nexport interface DocumentScope<D> {\n  /** Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /** Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n  /** Insert a document into this database.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument)\n  ): Promise<DocumentInsertResponse>;\n  /**\n   * Insert a document into this database with options.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument),\n    params: DocumentInsertParams | string | null\n  ): Promise<DocumentInsertResponse>;\n  /** Fetch a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(docname: string): Promise<DocumentGetResponse & D>;\n  /** Fetch a document from this database with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(\n    docname: string,\n    params?: DocumentGetParams\n  ): Promise<DocumentGetResponse & D>;\n  /** Delete a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\n  destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;\n  /** Bulk insert/update/delete multiple documents in this database.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(docs: BulkModifyDocsWrapper): Promise<DocumentBulkResponse[]>;\n  /** Bulk insert/update/delete multiple documents in this database, with options.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(\n    docs: BulkModifyDocsWrapper,\n    params: any\n  ): Promise<DocumentInsertResponse[]>;\n  /** Create a Mango index.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\n  createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;\n  /** Fetch a list of documents by _id with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\n  fetch(\n    docnames: BulkFetchDocsWrapper,\n    params: DocumentFetchParams\n  ): Promise<DocumentFetchResponse<D>>;\n  /** Run Mango query.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */\n  find(query: MangoQuery): Promise<MangoResponse<D>>;\n  /** Server scope */\n  server: ServerScope;\n}\n"]}

package/lib/index.cjs

@@ -41,6 +41,6 @@ __exportStar(require("./utils.cjs"), exports);
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-exports.VERSION = "0.0.2";
+exports.VERSION = "0.1.1";
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwrQ0FBNkI7QUFDN0IsMENBQXdCO0FBQ3hCLDhDQUE0QjtBQUM1Qiw0Q0FBMEI7QUFDMUIsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6QiwwQ0FBd0I7QUFDeEIsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vaW5kZXhlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcXVlbmNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE1vZHVsZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTW9kdWxlIGRlc2NyaXB0aW9uXG4gKiBAbW9kdWxlIHRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgTmFtZXNwYWNlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBOYW1lc3BhY2UgZGVzY3JpcHRpb25cbiAqIEBuYW1lc3BhY2UgTmFtZXNwYWNlXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgc3RvcmVzIHRoZSBjdXJyZW50IHBhY2thZ2UgdmVyc2lvblxuICogQGRlc2NyaXB0aW9uIHRoaXMgaXMgaG93IHlvdSBzaG91bGQgZG9jdW1lbnQgYSBjb25zdGFudFxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIwLjAuMlwiO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwrQ0FBNkI7QUFDN0IsMENBQXdCO0FBQ3hCLDhDQUE0QjtBQUM1Qiw0Q0FBMEI7QUFDMUIsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6QiwwQ0FBd0I7QUFDeEIsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vaW5kZXhlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcXVlbmNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE1vZHVsZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTW9kdWxlIGRlc2NyaXB0aW9uXG4gKiBAbW9kdWxlIHRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgTmFtZXNwYWNlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBOYW1lc3BhY2UgZGVzY3JpcHRpb25cbiAqIEBuYW1lc3BhY2UgTmFtZXNwYWNlXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgc3RvcmVzIHRoZSBjdXJyZW50IHBhY2thZ2UgdmVyc2lvblxuICogQGRlc2NyaXB0aW9uIHRoaXMgaXMgaG93IHlvdSBzaG91bGQgZG9jdW1lbnQgYSBjb25zdGFudFxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIwLjEuMVwiO1xuIl19

package/lib/index.d.ts

@@ -24,4 +24,4 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-export declare const VERSION = "0.0.2";
+export declare const VERSION = "0.1.1";

package/lib/model/CouchDBSequence.cjs

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sequence = void 0;
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
 const core_1 = require("@decaf-ts/core");
+const constants_1 = require("../constants.cjs");
 let Sequence = class Sequence extends core_1.BaseModel {
     constructor(seq) {
         super(seq);
@@ -43,10 +44,9 @@ __decorate([
     __metadata("design:type", Object)
 ], Sequence.prototype, "current", void 0);
 exports.Sequence = Sequence = __decorate([
-    (0, core_1.table)("??sequence"),
-    (0, core_1.uses)("nano"),
+    (0, core_1.table)(constants_1.CouchDBKeys.SEQUENCE),
     (0, decorator_validation_1.model)(),
     __metadata("design:paramtypes", [Object])
 ], Sequence);
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9tb2RlbC9Db3VjaERCU2VxdWVuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEseUVBQTJFO0FBQzNFLHlDQUFtRTtBQUs1RCxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVMsU0FBUSxnQkFBUztJQW9CckMsWUFBWSxHQUF3QjtRQUNsQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFwQmI7Ozs7O1dBS0c7UUFFSCxPQUFFLEdBQVksU0FBUyxDQUFDO1FBQ3hCOzs7Ozs7V0FNRztRQUdILFlBQU8sR0FBcUIsU0FBUyxDQUFDO0lBSXRDLENBQUM7Q0FDRixDQUFBO0FBdkJZLDRCQUFRO0FBUW5CO0lBREMsSUFBQSxTQUFFLEdBQUU7O29DQUNtQjtBQVV4QjtJQUZDLElBQUEsK0JBQVEsR0FBRTtJQUNWLElBQUEsWUFBSyxHQUFFOzt5Q0FDOEI7bUJBbEIzQixRQUFRO0lBSHBCLElBQUEsWUFBSyxFQUFDLFlBQVksQ0FBQztJQUNuQixJQUFBLFdBQUksRUFBQyxNQUFNLENBQUM7SUFDWixJQUFBLDRCQUFLLEdBQUU7O0dBQ0ssUUFBUSxDQXVCcEIiLCJmaWxlIjoibW9kZWwvQ291Y2hEQlNlcXVlbmNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbW9kZWwsIE1vZGVsQXJnLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IEJhc2VNb2RlbCwgcGssIGluZGV4LCB0YWJsZSwgdXNlcyB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuXG5AdGFibGUoXCI/P3NlcXVlbmNlXCIpXG5AdXNlcyhcIm5hbm9cIilcbkBtb2RlbCgpXG5leHBvcnQgY2xhc3MgU2VxdWVuY2UgZXh0ZW5kcyBCYXNlTW9kZWwge1xuICAvKipcbiAgICogQHN1bW1hcnkgdGhlIFByaW1hcnkga2V5IGZvciB0aGUgREJTZXF1ZW5jZVxuICAgKiBAcHJvcCBuYW1lXG4gICAqXG4gICAqIEBzZWUgcGtcbiAgICovXG4gIEBwaygpXG4gIGlkPzogc3RyaW5nID0gdW5kZWZpbmVkO1xuICAvKipcbiAgICogQHN1bW1hcnkgdGhlIGN1cnJlbnQgdmFsdWUgZm9yIHRoZSBEQlNlcXVlbmNlXG4gICAqIEBwcm9wIGN1cnJlbnRcbiAgICpcbiAgICogQHNlZSByZXF1aXJlZFxuICAgKiBAc2VlIGluZGV4XG4gICAqL1xuICBAcmVxdWlyZWQoKVxuICBAaW5kZXgoKVxuICBjdXJyZW50Pzogc3RyaW5nIHwgbnVtYmVyID0gdW5kZWZpbmVkO1xuXG4gIGNvbnN0cnVjdG9yKHNlcT86IE1vZGVsQXJnPFNlcXVlbmNlPikge1xuICAgIHN1cGVyKHNlcSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9tb2RlbC9Db3VjaERCU2VxdWVuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEseUVBQTJFO0FBQzNFLHlDQUE2RDtBQUM3RCw0Q0FBMkM7QUFJcEMsSUFBTSxRQUFRLEdBQWQsTUFBTSxRQUFTLFNBQVEsZ0JBQVM7SUFvQnJDLFlBQVksR0FBd0I7UUFDbEMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBcEJiOzs7OztXQUtHO1FBRUgsT0FBRSxHQUFZLFNBQVMsQ0FBQztRQUN4Qjs7Ozs7O1dBTUc7UUFHSCxZQUFPLEdBQXFCLFNBQVMsQ0FBQztJQUl0QyxDQUFDO0NBQ0YsQ0FBQTtBQXZCWSw0QkFBUTtBQVFuQjtJQURDLElBQUEsU0FBRSxHQUFFOztvQ0FDbUI7QUFVeEI7SUFGQyxJQUFBLCtCQUFRLEdBQUU7SUFDVixJQUFBLFlBQUssR0FBRTs7eUNBQzhCO21CQWxCM0IsUUFBUTtJQUZwQixJQUFBLFlBQUssRUFBQyx1QkFBVyxDQUFDLFFBQVEsQ0FBQztJQUMzQixJQUFBLDRCQUFLLEdBQUU7O0dBQ0ssUUFBUSxDQXVCcEIiLCJmaWxlIjoibW9kZWwvQ291Y2hEQlNlcXVlbmNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbW9kZWwsIE1vZGVsQXJnLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IEJhc2VNb2RlbCwgcGssIGluZGV4LCB0YWJsZSB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuaW1wb3J0IHsgQ291Y2hEQktleXMgfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5cbkB0YWJsZShDb3VjaERCS2V5cy5TRVFVRU5DRSlcbkBtb2RlbCgpXG5leHBvcnQgY2xhc3MgU2VxdWVuY2UgZXh0ZW5kcyBCYXNlTW9kZWwge1xuICAvKipcbiAgICogQHN1bW1hcnkgdGhlIFByaW1hcnkga2V5IGZvciB0aGUgREJTZXF1ZW5jZVxuICAgKiBAcHJvcCBuYW1lXG4gICAqXG4gICAqIEBzZWUgcGtcbiAgICovXG4gIEBwaygpXG4gIGlkPzogc3RyaW5nID0gdW5kZWZpbmVkO1xuICAvKipcbiAgICogQHN1bW1hcnkgdGhlIGN1cnJlbnQgdmFsdWUgZm9yIHRoZSBEQlNlcXVlbmNlXG4gICAqIEBwcm9wIGN1cnJlbnRcbiAgICpcbiAgICogQHNlZSByZXF1aXJlZFxuICAgKiBAc2VlIGluZGV4XG4gICAqL1xuICBAcmVxdWlyZWQoKVxuICBAaW5kZXgoKVxuICBjdXJyZW50Pzogc3RyaW5nIHwgbnVtYmVyID0gdW5kZWZpbmVkO1xuXG4gIGNvbnN0cnVjdG9yKHNlcT86IE1vZGVsQXJnPFNlcXVlbmNlPikge1xuICAgIHN1cGVyKHNlcSk7XG4gIH1cbn1cbiJdfQ==

package/lib/sequences/Sequence.cjs

@@ -1,13 +1,4 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CouchDBSequence = void 0;
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
@@ -28,8 +19,9 @@ const utils_1 = require("./utils.cjs");
  * @category Sequences
  */
 class CouchDBSequence extends core_2.Sequence {
-    constructor(options) {
+    constructor(options, adapter) {
         super(options);
+        this.repo = core_1.Repository.forModel(CouchDBSequence_1.Sequence, adapter.flavour);
     }
     /**
      * @summary Retrieves the current value for the sequence
@@ -123,9 +115,5 @@ class CouchDBSequence extends core_2.Sequence {
     }
 }
 exports.CouchDBSequence = CouchDBSequence;
-__decorate([
-    (0, core_1.repository)(CouchDBSequence_1.Sequence),
-    __metadata("design:type", Object)
-], CouchDBSequence.prototype, "repo", void 0);
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/sequences/Sequence.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yEAAoD;AACpD,8DAA2D;AAC3D,2DAIiC;AACjC,yCAA6D;AAC7D,yCAA0C;AAC1C,mCAA6C;AAE7C;;;;;;;;;;GAUG;AACH,MAAa,eAAgB,SAAQ,eAAQ;IAI3C,YAAY,OAAwB;QAClC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAQ,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAc,CAAC,CAAC;YAC3D,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAA0B,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,IAAI,CAAC,YAAY,6BAAa,EAAE,CAAC;gBAC/B,IAAI,OAAO,SAAS,KAAK,WAAW;oBAClC,MAAM,IAAI,6BAAa,CACrB,2DAA2D,CAC5D,CAAC;gBACJ,IAAI,CAAC;oBACH,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC/B,CAAC;gBAAC,OAAO,CAAM,EAAE,CAAC;oBAChB,MAAM,IAAI,6BAAa,CACrB,IAAA,yBAAE,EACA,qDAAqD,EACrD,SAAS,CAAC,QAAQ,EAAE,EACpB,CAAC,CACF,CACF,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,IAAI,6BAAa,CACrB,IAAA,yBAAE,EACA,wDAAwD,EACxD,IAAc,EACd,CAAC,CACF,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,KAA+B;QAC3C,OAAO,IAAA,0BAAkB,EAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,SAAS,CACrB,OAAiC,EACjC,KAAc;QAEd,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QACjD,IAAI,IAA8B,CAAC;QACnC,MAAM,aAAa,GAAG,KAAK,IAAI,WAAW,CAAC;QAC3C,IAAI,aAAa,GAAG,WAAW,KAAK,CAAC;YACnC,MAAM,IAAI,6BAAa,CACrB,iEAAiE,WAAW,EAAE,CAC/E,CAAC;QACJ,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,QAAQ;gBACX,IAAI,GAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,GAAG,aAAa,CAAC;gBACvD,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,GAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;gBAC/D,MAAM;YACR;gBACE,MAAM,IAAI,6BAAa,CAAC,qBAAqB,CAAC,CAAC;QACnD,CAAC;QACD,IAAI,GAAQ,CAAC;QACb,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,0BAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,IAAI,CAAC,CAAC,CAAC,YAAY,6BAAa,CAAC;gBAAE,MAAM,CAAC,CAAC;YAC3C,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,0BAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,GAAG,CAAC,OAAmC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI;QACR,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,KAAa;QACvB,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAW,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAW,CAAC;QACnE,MAAM,IAAI,GAA6B,MAAM,IAAI,CAAC,SAAS,CACzD,OAAO,EACN,IAAI,CAAC,KAAK,CAAC,KAAK,CAAY,GAAG,WAAW,CAC5C,CAAC;QACF,MAAM,KAAK,GAAiC,EAAE,CAAC;QAC/C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,WAAW,GAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAY,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;YAClC,MAAM,IAAI,6BAAa,CAAC,yBAAyB,CAAC,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAzHD,0CAyHC;AAvHW;IADT,IAAA,iBAAU,EAAC,0BAAG,CAAC;;6CACkB","file":"sequences/Sequence.js","sourcesContent":["import { sf } from \"@decaf-ts/decorator-validation\";\nimport { Sequence as Seq } from \"../model/CouchDBSequence\";\nimport {\n  InternalError,\n  IRepository,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { repository, SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { parseSequenceValue } from \"./utils\";\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n *\n * @category Sequences\n */\nexport class CouchDBSequence extends Sequence {\n  @repository(Seq)\n  protected repo!: IRepository<Seq>;\n\n  constructor(options: SequenceOptions) {\n    super(options);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            sf(\n              \"Failed to parse initial value for sequence {0}: {1}\",\n              startWith.toString(),\n              e\n            )\n          );\n        }\n      }\n      throw new InternalError(\n        sf(\n          \"Failed to retrieve current value for sequence {0}: {1}\",\n          name as string,\n          e\n        )\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return parseSequenceValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    try {\n      seq = await this.repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/sequences/Sequence.ts"],"names":[],"mappings":"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","file":"sequences/Sequence.js","sourcesContent":["import { sf } from \"@decaf-ts/decorator-validation\";\nimport { Sequence as Seq } from \"../model/CouchDBSequence\";\nimport {\n  InternalError,\n  IRepository,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { Adapter, Repository, SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { parseSequenceValue } from \"./utils\";\nimport { DocumentScope, MangoQuery } from \"../types\";\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n *\n * @category Sequences\n */\nexport class CouchDBSequence extends Sequence {\n  protected repo: IRepository<Seq>;\n\n  constructor(\n    options: SequenceOptions,\n    adapter: Adapter<DocumentScope<any>, MangoQuery>\n  ) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.flavour);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            sf(\n              \"Failed to parse initial value for sequence {0}: {1}\",\n              startWith.toString(),\n              e\n            )\n          );\n        }\n      }\n      throw new InternalError(\n        sf(\n          \"Failed to retrieve current value for sequence {0}: {1}\",\n          name as string,\n          e\n        )\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return parseSequenceValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    try {\n      seq = await this.repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n"]}

package/lib/sequences/Sequence.d.ts

@@ -1,7 +1,8 @@
 import { Sequence as Seq } from "../model/CouchDBSequence";
 import { IRepository } from "@decaf-ts/db-decorators";
-import { SequenceOptions } from "@decaf-ts/core";
+import { Adapter, SequenceOptions } from "@decaf-ts/core";
 import { Sequence } from "@decaf-ts/core";
+import { DocumentScope, MangoQuery } from "../types";
 /**
  * @summary Abstract implementation of a Sequence
  * @description provides the basic functionality for {@link Sequence}s
@@ -15,7 +16,7 @@ import { Sequence } from "@decaf-ts/core";
  */
 export declare class CouchDBSequence extends Sequence {
     protected repo: IRepository<Seq>;
-    constructor(options: SequenceOptions);
+    constructor(options: SequenceOptions, adapter: Adapter<DocumentScope<any>, MangoQuery>);
     /**
      * @summary Retrieves the current value for the sequence
      * @protected

package/lib/types.cjs

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/types.ts"],"names":[],"mappings":"","file":"types.js","sourcesContent":["/** Mango response.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoResponse<D> {\n  /** Array of documents matching the search.\n   *\n   * In each matching document, the fields specified in the fields part of the request body are listed, along with\n   * their values. */\n  docs: (D & { _id: string; _rev: string })[];\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Execution warnings */\n  warning?: string;\n\n  /** Basic execution statistics for a specific request. */\n  execution_stats?: MangoExecutionStats;\n}\n\n/** Mango execution stats.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics} */\nexport interface MangoExecutionStats {\n  /** Number of index keys examined. Currently always 0. */\n  total_keys_examined: number;\n\n  /** Number of documents fetched from the database / index.\n   *\n   * Equivalent to using include_docs = true in a view. */\n  total_docs_examined: number;\n\n  /** Number of documents fetched from the database using an out-of-band document fetch.\n   *\n   * This is only non-zero when read quorum > 1 is specified in the query parameters. */\n  total_quorum_docs_examined: number;\n\n  /** Number of results returned from the query. */\n  results_returned: number;\n\n  /** Total execution time in milliseconds as measured by the database. */\n  execution_time_ms: number;\n}\n\n/** Document insert response:\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n\n/** Mango create index response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexResponse {\n  /** Flag to show whether the index was created or one already exists.\n   *\n   * Can be “created” or “exists”. */\n  result: string;\n\n  /** Id of the design document the index was created in. */\n  id: string;\n\n  /** Name of the index created. */\n  name: string;\n}\n\n/** Document delete response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\nexport interface DocumentDestroyResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n/** Document get response:\n * @see docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetResponse {\n  /** Document ID. */\n  _id: string;\n\n  /** Revision MVCC token. */\n  _rev: string;\n\n  /** Deletion flag. Available if document was removed. */\n  _deleted?: boolean;\n\n  /** Attachment’s stubs. Available if document has any attachments. */\n  _attachments?: any;\n\n  /** List of conflicted revisions. Available if requested with conflicts=true query parameter. */\n  _conflicts?: any[];\n\n  /** List of deleted conflicted revisions. Available if requested with deleted_conflicts=true query parameter. */\n  _deleted_conflicts?: any[];\n\n  /** Document’s update sequence in current database. Available if requested with local_seq=true query parameter. */\n  _local_seq?: string;\n\n  /** List of objects with information about local revisions and their status.\n   *\n   * Available if requested with open_revs query parameter. */\n  _revs_info?: any[];\n\n  /** List of local revision tokens without.\n   *\n   * Available if requested with revs=true query parameter. */\n  _revisions?: any;\n}\n\nexport interface BulkModifyDocsWrapper {\n  docs: any[];\n}\n\nexport interface BulkFetchDocsWrapper {\n  keys: string[];\n}\n/** Bulk API response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_bulk_docs} */\nexport interface DocumentBulkResponse {\n  /** Document ID. Available in all cases */\n  id: string;\n\n  /** New document revision token. Available if document has saved without errors. */\n  rev?: string;\n\n  /** Error type. Available if response code is 4xx */\n  error?: string;\n\n  /** Error reason. Available if response code is 4xx */\n  reason?: string;\n}\n/** Mango create index parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexRequest {\n  /** JSON object describing the index to create */\n  index: {\n    /** Array of field names following the sort syntax. */\n    fields: SortOrder[];\n\n    /** A selector to apply to documents at indexing time, creating a partial index. */\n    partial_filter_selector?: MangoSelector;\n  };\n\n  /** Name of the design document in which the index will be created. */\n  ddoc?: string;\n\n  /** Name of the index. If no name is provided, a name will be generated automatically. */\n  name?: string;\n\n  /** Can be \"json\" or \"text\".\n   *\n   * @default \"json\" */\n  type?: \"json\" | \"text\";\n\n  /** This field sets whether the created index will be a partitioned or global index. */\n  partitioned?: boolean;\n}\n\nexport type MangoValue = number | string | Date | boolean | object | null;\nexport type MangoOperator =\n  | \"$lt\"\n  | \"$lte\"\n  | \"$eq\"\n  | \"$ne\"\n  | \"$gte\"\n  | \"$gt\"\n  | \"$exists\"\n  | \"$type\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$size\"\n  | \"$mod\"\n  | \"$regex\"\n  | \"$or\"\n  | \"$and\"\n  | \"$nor\"\n  | \"$not\"\n  | \"$all\"\n  | \"$allMatch\"\n  | \"$elemMatch\";\n/** Mango selector syntax.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax} */\nexport type MangoSelector = {\n  [K in MangoOperator | string]:\n    | MangoSelector\n    | MangoSelector[]\n    | MangoValue\n    | MangoValue[];\n};\n\n/** Mango sort syntax\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax} */\nexport type SortOrder = string | string[] | { [key: string]: \"asc\" | \"desc\" };\n\n/** Mango query syntax.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoQuery {\n  /** JSON object describing criteria used to select documents. */\n  selector: MangoSelector;\n\n  /** Maximum number of results returned. @default 25 */\n  limit?: number;\n\n  /** Skip the first 'n' results, where 'n' is the value specified. */\n  skip?: number;\n\n  /** JSON array following sort syntax. */\n  sort?: SortOrder[];\n\n  /** JSON array specifying which fields of each object should be returned.\n   *\n   * If it is omitted, the entire object is returned.\n   *\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */\n  fields?: string[];\n\n  /* Instruct a query to use a specific index.\n   *\n   * Specified either as \"<design_document>\" or [\"<design_document>\", \"<index_name>\"]. */\n  use_index?: string | [string, string];\n\n  /** Read quorum needed for the result.\n   *\n   * @default 1 */\n  r?: number;\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Whether to update the index prior to returning the result.\n   *\n   * @default true */\n  update?: boolean;\n\n  /** Whether or not the view results should be returned from a “stable” set of shards. */\n  stable?: boolean;\n\n  /** Combination of update = false and stable = true options.\n   *\n   * Possible options: \"ok\", false (default). */\n  stale?: \"ok\" | false;\n\n  /** Include execution statistics in the query response.\n   *\n   * Optional, default: false. */\n  execution_stats?: boolean;\n}\n\n/** Database authentication response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\nexport interface DatabaseAuthResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** Username */\n  name: string;\n\n  /** List of user roles */\n  roles: string[];\n}\n\n/** Database _session response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\nexport interface DatabaseSessionResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** User context for the current user */\n  userCtx: any;\n\n  /** Server authentication configuration */\n  info: any;\n}\n\n// -------------------------------------\n// Document\n// -------------------------------------\n\nexport interface MaybeIdentifiedDocument {\n  _id?: string;\n}\n\nexport interface IdentifiedDocument {\n  _id: string;\n}\n\nexport interface MaybeRevisionedDocument {\n  _rev?: string;\n}\n\nexport interface RevisionedDocument {\n  _rev: string;\n}\n\nexport interface MaybeDocument\n  extends MaybeIdentifiedDocument,\n    MaybeRevisionedDocument {}\n\nexport interface Document extends IdentifiedDocument, RevisionedDocument {}\n\n// -------------------------------------\n// View\n// -------------------------------------\n\nexport type DocumentInfer<D> = (doc: D & Document) => void;\nexport interface View<D> {\n  map?: string | DocumentInfer<D>;\n  reduce?: string | DocumentInfer<D>;\n}\n\nexport interface ViewDocument<D> extends IdentifiedDocument {\n  views: {\n    [name: string]: View<D>;\n  };\n}\n\n/** Document insert parameters.\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertParams {\n  /** Document ID */\n  docName?: string;\n\n  /** Document’s revision if updating an existing document. Alternative to If-Match header or document key. */\n  rev?: string;\n\n  /** Stores document in batch mode. */\n  batch?: \"ok\";\n\n  /** Prevents insertion of a conflicting document.\n   *\n   * If false, a well-formed `_rev` must be included in the document. `new_edits=false` is used by the replicator to\n   * insert documents into the target database even if that leads to the creation of conflicts.\n   *\n   * @default true */\n  new_edits?: boolean;\n}\n\n/** Document get parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetParams {\n  /** Includes attachments bodies in response.\n   *\n   * @default false */\n  attachments?: boolean;\n\n  /** Includes encoding information in attachment stubs if the particular attachment is compressed.\n   *\n   * @default false */\n  att_encoding_info?: boolean;\n\n  /** Includes attachments only since specified revisions.\n   *\n   * Doesn’t includes attachments for specified revisions. */\n  atts_since?: any[];\n\n  /** Includes information about conflicts in document.\n   *\n   * @default false */\n  conflicts?: boolean;\n\n  /** Includes information about deleted conflicted revisions.\n   *\n   * @default false */\n  deleted_conflicts?: boolean;\n\n  /** Forces retrieving latest “leaf” revision, no matter what rev was requested.\n   *\n   * @default false */\n  latest?: boolean;\n\n  /** Includes last update sequence for the document.\n   *\n   * @default false */\n  local_seq?: boolean;\n\n  /** Acts same as specifying all conflicts, deleted_conflicts and revs_info query parameters.\n   *\n   * @default false */\n  meta?: boolean;\n\n  /** Retrieves documents of specified leaf revisions.\n   *\n   * Additionally, it accepts value as all to return all leaf revisions. */\n  open_revs?: any[];\n\n  /** Retrieves document of specified revision. */\n  rev?: string;\n\n  /** Includes list of all known document revisions. */\n  revs?: boolean;\n\n  /** Includes detailed information for all known document revisions.\n   *\n   * @default false */\n  revs_info?: boolean;\n}\n\n/** Server scope */\nexport interface ServerScope {\n  /**\n   * Returns a database object that allows you to perform operations against that database.\n   * @see README: {@link https://www.npmjs.com/package/nano#nanousename}\n   */\n  use<D>(db: string): DocumentScope<D>;\n  /**\n   * Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /**\n   * Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n}\n\n/** Documents scope */\nexport interface DocumentScope<D> {\n  /** Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /** Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n  /** Insert a document into this database.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument)\n  ): Promise<DocumentInsertResponse>;\n  /**\n   * Insert a document into this database with options.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument),\n    params: DocumentInsertParams | string | null\n  ): Promise<DocumentInsertResponse>;\n  /** Fetch a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(docname: string): Promise<DocumentGetResponse & D>;\n  /** Fetch a document from this database with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(\n    docname: string,\n    params?: DocumentGetParams\n  ): Promise<DocumentGetResponse & D>;\n  /** Delete a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\n  destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;\n  /** Bulk insert/update/delete multiple documents in this database.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(docs: BulkModifyDocsWrapper): Promise<DocumentBulkResponse[]>;\n  /** Bulk insert/update/delete multiple documents in this database, with options.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(\n    docs: BulkModifyDocsWrapper,\n    params: any\n  ): Promise<DocumentInsertResponse[]>;\n  /** Create a Mango index.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\n  createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;\n\n  /** Run Mango query.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */\n  find(query: MangoQuery): Promise<MangoResponse<D>>;\n  /** Server scope */\n  server: ServerScope;\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/types.ts"],"names":[],"mappings":"","file":"types.js","sourcesContent":["/** Mango response.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoResponse<D> {\n  /** Array of documents matching the search.\n   *\n   * In each matching document, the fields specified in the fields part of the request body are listed, along with\n   * their values. */\n  docs: (D & { _id: string; _rev: string })[];\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Execution warnings */\n  warning?: string;\n\n  /** Basic execution statistics for a specific request. */\n  execution_stats?: MangoExecutionStats;\n}\n\n/** Mango execution stats.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#execution-statistics} */\nexport interface MangoExecutionStats {\n  /** Number of index keys examined. Currently always 0. */\n  total_keys_examined: number;\n\n  /** Number of documents fetched from the database / index.\n   *\n   * Equivalent to using include_docs = true in a view. */\n  total_docs_examined: number;\n\n  /** Number of documents fetched from the database using an out-of-band document fetch.\n   *\n   * This is only non-zero when read quorum > 1 is specified in the query parameters. */\n  total_quorum_docs_examined: number;\n\n  /** Number of results returned from the query. */\n  results_returned: number;\n\n  /** Total execution time in milliseconds as measured by the database. */\n  execution_time_ms: number;\n}\n\n/** Document insert response:\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n\n/** Mango create index response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexResponse {\n  /** Flag to show whether the index was created or one already exists.\n   *\n   * Can be “created” or “exists”. */\n  result: string;\n\n  /** Id of the design document the index was created in. */\n  id: string;\n\n  /** Name of the index created. */\n  name: string;\n}\n\n/** Document delete response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\nexport interface DocumentDestroyResponse {\n  /** Document ID */\n  id: string;\n\n  /** Operation status */\n  ok: boolean;\n\n  /** Revision MVCC token */\n  rev: string;\n}\n/** Document get response:\n * @see docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetResponse {\n  /** Document ID. */\n  _id: string;\n\n  /** Revision MVCC token. */\n  _rev: string;\n\n  /** Deletion flag. Available if document was removed. */\n  _deleted?: boolean;\n\n  /** Attachment’s stubs. Available if document has any attachments. */\n  _attachments?: any;\n\n  /** List of conflicted revisions. Available if requested with conflicts=true query parameter. */\n  _conflicts?: any[];\n\n  /** List of deleted conflicted revisions. Available if requested with deleted_conflicts=true query parameter. */\n  _deleted_conflicts?: any[];\n\n  /** Document’s update sequence in current database. Available if requested with local_seq=true query parameter. */\n  _local_seq?: string;\n\n  /** List of objects with information about local revisions and their status.\n   *\n   * Available if requested with open_revs query parameter. */\n  _revs_info?: any[];\n\n  /** List of local revision tokens without.\n   *\n   * Available if requested with revs=true query parameter. */\n  _revisions?: any;\n}\n\nexport interface BulkModifyDocsWrapper {\n  docs: any[];\n}\n\nexport interface BulkFetchDocsWrapper {\n  keys: string[];\n}\n/** Bulk API response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_bulk_docs} */\nexport interface DocumentBulkResponse {\n  /** Document ID. Available in all cases */\n  id: string;\n\n  /** New document revision token. Available if document has saved without errors. */\n  rev?: string;\n\n  /** Error type. Available if response code is 4xx */\n  error?: string;\n\n  /** Error reason. Available if response code is 4xx */\n  reason?: string;\n}\n/** Mango create index parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\nexport interface CreateIndexRequest {\n  /** JSON object describing the index to create */\n  index: {\n    /** Array of field names following the sort syntax. */\n    fields: SortOrder[];\n\n    /** A selector to apply to documents at indexing time, creating a partial index. */\n    partial_filter_selector?: MangoSelector;\n  };\n\n  /** Name of the design document in which the index will be created. */\n  ddoc?: string;\n\n  /** Name of the index. If no name is provided, a name will be generated automatically. */\n  name?: string;\n\n  /** Can be \"json\" or \"text\".\n   *\n   * @default \"json\" */\n  type?: \"json\" | \"text\";\n\n  /** This field sets whether the created index will be a partitioned or global index. */\n  partitioned?: boolean;\n}\n\nexport type MangoValue = number | string | Date | boolean | object | null;\nexport type MangoOperator =\n  | \"$lt\"\n  | \"$lte\"\n  | \"$eq\"\n  | \"$ne\"\n  | \"$gte\"\n  | \"$gt\"\n  | \"$exists\"\n  | \"$type\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$size\"\n  | \"$mod\"\n  | \"$regex\"\n  | \"$or\"\n  | \"$and\"\n  | \"$nor\"\n  | \"$not\"\n  | \"$all\"\n  | \"$allMatch\"\n  | \"$elemMatch\";\n/** Mango selector syntax.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#selector-syntax} */\nexport type MangoSelector = {\n  [K in MangoOperator | string]:\n    | MangoSelector\n    | MangoSelector[]\n    | MangoValue\n    | MangoValue[];\n};\n\n/** Mango sort syntax\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax} */\nexport type SortOrder = string | string[] | { [key: string]: \"asc\" | \"desc\" };\n\n/** Mango query syntax.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/find.html#db-find}  */\nexport interface MangoQuery {\n  /** JSON object describing criteria used to select documents. */\n  selector: MangoSelector;\n\n  /** Maximum number of results returned. @default 25 */\n  limit?: number;\n\n  /** Skip the first 'n' results, where 'n' is the value specified. */\n  skip?: number;\n\n  /** JSON array following sort syntax. */\n  sort?: SortOrder[];\n\n  /** JSON array specifying which fields of each object should be returned.\n   *\n   * If it is omitted, the entire object is returned.\n   *\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#filtering-fields} */\n  fields?: string[];\n\n  /* Instruct a query to use a specific index.\n   *\n   * Specified either as \"<design_document>\" or [\"<design_document>\", \"<index_name>\"]. */\n  use_index?: string | [string, string];\n\n  /** Read quorum needed for the result.\n   *\n   * @default 1 */\n  r?: number;\n\n  /** A string that enables you to specify which page of results you require.\n   *\n   * Used for paging through result sets. */\n  bookmark?: string;\n\n  /** Whether to update the index prior to returning the result.\n   *\n   * @default true */\n  update?: boolean;\n\n  /** Whether or not the view results should be returned from a “stable” set of shards. */\n  stable?: boolean;\n\n  /** Combination of update = false and stable = true options.\n   *\n   * Possible options: \"ok\", false (default). */\n  stale?: \"ok\" | false;\n\n  /** Include execution statistics in the query response.\n   *\n   * Optional, default: false. */\n  execution_stats?: boolean;\n}\n\n/** Database authentication response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\nexport interface DatabaseAuthResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** Username */\n  name: string;\n\n  /** List of user roles */\n  roles: string[];\n}\n\n/** Database _session response.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\nexport interface DatabaseSessionResponse {\n  /** Operation status */\n  ok: boolean;\n\n  /** User context for the current user */\n  userCtx: any;\n\n  /** Server authentication configuration */\n  info: any;\n}\n\n// -------------------------------------\n// Document\n// -------------------------------------\n\nexport interface MaybeIdentifiedDocument {\n  _id?: string;\n}\n\nexport interface IdentifiedDocument {\n  _id: string;\n}\n\nexport interface MaybeRevisionedDocument {\n  _rev?: string;\n}\n\nexport interface RevisionedDocument {\n  _rev: string;\n}\n\nexport interface MaybeDocument\n  extends MaybeIdentifiedDocument,\n    MaybeRevisionedDocument {}\n\nexport interface Document extends IdentifiedDocument, RevisionedDocument {}\n\n// -------------------------------------\n// View\n// -------------------------------------\n\nexport type DocumentInfer<D> = (doc: D & Document) => void;\nexport interface View<D> {\n  map?: string | DocumentInfer<D>;\n  reduce?: string | DocumentInfer<D>;\n}\n\nexport interface ViewDocument<D> extends IdentifiedDocument {\n  views: {\n    [name: string]: View<D>;\n  };\n}\n\n/** Document insert parameters.\n * @see POST docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n * @see PUT docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\nexport interface DocumentInsertParams {\n  /** Document ID */\n  docName?: string;\n\n  /** Document’s revision if updating an existing document. Alternative to If-Match header or document key. */\n  rev?: string;\n\n  /** Stores document in batch mode. */\n  batch?: \"ok\";\n\n  /** Prevents insertion of a conflicting document.\n   *\n   * If false, a well-formed `_rev` must be included in the document. `new_edits=false` is used by the replicator to\n   * insert documents into the target database even if that leads to the creation of conflicts.\n   *\n   * @default true */\n  new_edits?: boolean;\n}\n\n/** Document get parameters.\n * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\nexport interface DocumentGetParams {\n  /** Includes attachments bodies in response.\n   *\n   * @default false */\n  attachments?: boolean;\n\n  /** Includes encoding information in attachment stubs if the particular attachment is compressed.\n   *\n   * @default false */\n  att_encoding_info?: boolean;\n\n  /** Includes attachments only since specified revisions.\n   *\n   * Doesn’t includes attachments for specified revisions. */\n  atts_since?: any[];\n\n  /** Includes information about conflicts in document.\n   *\n   * @default false */\n  conflicts?: boolean;\n\n  /** Includes information about deleted conflicted revisions.\n   *\n   * @default false */\n  deleted_conflicts?: boolean;\n\n  /** Forces retrieving latest “leaf” revision, no matter what rev was requested.\n   *\n   * @default false */\n  latest?: boolean;\n\n  /** Includes last update sequence for the document.\n   *\n   * @default false */\n  local_seq?: boolean;\n\n  /** Acts same as specifying all conflicts, deleted_conflicts and revs_info query parameters.\n   *\n   * @default false */\n  meta?: boolean;\n\n  /** Retrieves documents of specified leaf revisions.\n   *\n   * Additionally, it accepts value as all to return all leaf revisions. */\n  open_revs?: any[];\n\n  /** Retrieves document of specified revision. */\n  rev?: string;\n\n  /** Includes list of all known document revisions. */\n  revs?: boolean;\n\n  /** Includes detailed information for all known document revisions.\n   *\n   * @default false */\n  revs_info?: boolean;\n}\n\n/** Server scope */\nexport interface ServerScope {\n  /**\n   * Returns a database object that allows you to perform operations against that database.\n   * @see README: {@link https://www.npmjs.com/package/nano#nanousename}\n   */\n  use<D>(db: string): DocumentScope<D>;\n  /**\n   * Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /**\n   * Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n}\n\n/** Fetch with POST _all_docs parameters.\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\nexport interface DocumentFetchParams {\n  conflicts?: boolean;\n  descending?: boolean;\n  end_key?: string;\n  end_key_doc_id?: string;\n  include_docs?: boolean;\n  inclusive_end?: boolean;\n  key?: string;\n  keys?: string | string[];\n  limit?: number;\n  skip?: number;\n  stale?: string;\n  start_key?: string;\n  start_key_doc_id?: string;\n  update_seq?: boolean;\n}\n\n/** Document fetch error */\nexport interface DocumentLookupFailure {\n  key: string;\n  error: string;\n}\n/** Bulk API per-document response. */\nexport interface DocumentResponseRowMeta {\n  id: string;\n  key: string;\n  value: {\n    rev: string;\n  };\n  error?: string;\n}\n\n/** Bulk API per-document response with document body. */\nexport interface DocumentResponseRow<D> extends DocumentResponseRowMeta {\n  doc?: D & Document;\n}\n\n/** Fetch with POST _all_docs response\n * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\nexport interface DocumentFetchResponse<D> {\n  offset: number;\n  rows: Array<DocumentResponseRow<D> | DocumentLookupFailure>;\n  total_rows: number;\n  update_seq?: number | string;\n}\n\n/** Documents scope */\nexport interface DocumentScope<D> {\n  /** Initiates new session for specified user credentials by providing Cookie value.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#cookie-authentication} */\n  auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;\n  /** Returns information about the authenticated user, including a User Context Object, the authentication method and database that were used, and a list of configured authentication handlers on the server.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */\n  session(): Promise<DatabaseSessionResponse>;\n  /** Insert a document into this database.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument)\n  ): Promise<DocumentInsertResponse>;\n  /**\n   * Insert a document into this database with options.\n   * @see POST Docs: {@link http://docs.couchdb.org/en/latest/api/database/common.html#post--db}\n   * @see PUT Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#put--db-docid} */\n  insert(\n    document: ViewDocument<D> | (D & MaybeDocument),\n    params: DocumentInsertParams | string | null\n  ): Promise<DocumentInsertResponse>;\n  /** Fetch a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(docname: string): Promise<DocumentGetResponse & D>;\n  /** Fetch a document from this database with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#get--db-docid} */\n  get(\n    docname: string,\n    params?: DocumentGetParams\n  ): Promise<DocumentGetResponse & D>;\n  /** Delete a document from this database.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/document/common.html#delete--db-docid} */\n  destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;\n  /** Bulk insert/update/delete multiple documents in this database.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(docs: BulkModifyDocsWrapper): Promise<DocumentBulkResponse[]>;\n  /** Bulk insert/update/delete multiple documents in this database, with options.\n   * @see Docs: {@link https://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-docs} */\n  bulk(\n    docs: BulkModifyDocsWrapper,\n    params: any\n  ): Promise<DocumentInsertResponse[]>;\n  /** Create a Mango index.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */\n  createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;\n  /** Fetch a list of documents by _id with options.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */\n  fetch(\n    docnames: BulkFetchDocsWrapper,\n    params: DocumentFetchParams\n  ): Promise<DocumentFetchResponse<D>>;\n  /** Run Mango query.\n   * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */\n  find(query: MangoQuery): Promise<MangoResponse<D>>;\n  /** Server scope */\n  server: ServerScope;\n}\n"]}

package/lib/types.d.ts

@@ -315,6 +315,50 @@ export interface ServerScope {
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/server/authn.html#get--_session} */
     session(): Promise<DatabaseSessionResponse>;
 }
+/** Fetch with POST _all_docs parameters.
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+export interface DocumentFetchParams {
+    conflicts?: boolean;
+    descending?: boolean;
+    end_key?: string;
+    end_key_doc_id?: string;
+    include_docs?: boolean;
+    inclusive_end?: boolean;
+    key?: string;
+    keys?: string | string[];
+    limit?: number;
+    skip?: number;
+    stale?: string;
+    start_key?: string;
+    start_key_doc_id?: string;
+    update_seq?: boolean;
+}
+/** Document fetch error */
+export interface DocumentLookupFailure {
+    key: string;
+    error: string;
+}
+/** Bulk API per-document response. */
+export interface DocumentResponseRowMeta {
+    id: string;
+    key: string;
+    value: {
+        rev: string;
+    };
+    error?: string;
+}
+/** Bulk API per-document response with document body. */
+export interface DocumentResponseRow<D> extends DocumentResponseRowMeta {
+    doc?: D & Document;
+}
+/** Fetch with POST _all_docs response
+ * @see Docs: {@link https://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+export interface DocumentFetchResponse<D> {
+    offset: number;
+    rows: Array<DocumentResponseRow<D> | DocumentLookupFailure>;
+    total_rows: number;
+    update_seq?: number | string;
+}
 /** Documents scope */
 export interface DocumentScope<D> {
     /** Initiates new session for specified user credentials by providing Cookie value.
@@ -350,6 +394,9 @@ export interface DocumentScope<D> {
     /** Create a Mango index.
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-index} */
     createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;
+    /** Fetch a list of documents by _id with options.
+     * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/bulk-api.html#post--db-_all_docs} */
+    fetch(docnames: BulkFetchDocsWrapper, params: DocumentFetchParams): Promise<DocumentFetchResponse<D>>;
     /** Run Mango query.
      * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#db-find} */
     find(query: MangoQuery): Promise<MangoResponse<D>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-couchdb",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "template for ts projects",
   "type": "module",
   "exports": {