@decaf-ts/for-couchdb 0.0.2 → 0.1.0

package/lib/esm/query/factory.d.ts

@@ -1,5 +1,4 @@
 import { ClauseFactory, Condition, FromClause, FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector, Statement } from "@decaf-ts/core";
-import { DocumentScope, MangoQuery } from "nano";
 import { LimitClause } from "@decaf-ts/core";
 import { SelectClause } from "@decaf-ts/core";
 import { WhereClause } from "@decaf-ts/core";
@@ -10,6 +9,7 @@ import { ValuesClause } from "@decaf-ts/core";
 import { InsertClause } from "@decaf-ts/core";
 import { Model } from "@decaf-ts/decorator-validation";
 import { CouchDBAdapter } from "../adapter";
+import { DocumentScope, MangoQuery } from "../types";
 export declare class Factory extends ClauseFactory<DocumentScope<any>, MangoQuery> {
     constructor(adapter: CouchDBAdapter);
     from<M extends Model>(statement: Statement<MangoQuery>, selector: FromSelector<M>): FromClause<MangoQuery, M>;

package/lib/esm/query/factory.js

@@ -115,4 +115,4 @@ export class Factory extends ClauseFactory {
     }
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/factory.ts"],"names":[],"mappings":"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","file":"query/factory.js","sourcesContent":["import {\n  ClauseFactory,\n  Condition,\n  FromClause,\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  QueryError,\n  SelectSelector,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { DocumentScope, MangoQuery, MangoSelector } from \"nano\";\nimport { LimitClause } from \"@decaf-ts/core\";\nimport { SelectClause } from \"@decaf-ts/core\";\nimport { WhereClause } from \"@decaf-ts/core\";\nimport { OffsetClause } from \"@decaf-ts/core\";\nimport { OrderByClause } from \"@decaf-ts/core\";\nimport { GroupByClause } from \"@decaf-ts/core\";\nimport { ValuesClause } from \"@decaf-ts/core\";\nimport { InsertClause } from \"@decaf-ts/core\";\nimport { CouchDBFromClause } from \"./FromClause\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { CouchDBInsertClause } from \"./InsertClause\";\nimport { CouchDBStatement } from \"./Statement\";\nimport { CouchDBWhereClause } from \"./WhereClause\";\nimport { CouchDBSelectClause } from \"./SelectClause\";\nimport { CouchDBValuesClause } from \"./ValuesClause\";\nimport { CouchDBOperator } from \"./constants\";\nimport { CouchDBAdapter } from \"../adapter\";\n\nexport class Factory extends ClauseFactory<DocumentScope<any>, MangoQuery> {\n  constructor(adapter: CouchDBAdapter) {\n    super(adapter);\n  }\n\n  from<M extends Model>(\n    statement: Statement<MangoQuery>,\n    selector: FromSelector<M>\n  ): FromClause<MangoQuery, M> {\n    return new CouchDBFromClause({ statement: statement, selector: selector });\n  }\n\n  groupBy(\n    statement: Statement<MangoQuery>,\n    selector: GroupBySelector\n  ): GroupByClause<MangoQuery> {\n    return new (class extends GroupByClause<MangoQuery> {\n      constructor(clause: ModelArg<GroupByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      build(query: MangoQuery): MangoQuery {\n        throw new InternalError(\"Not implemented\");\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  insert<M extends Model>(): InsertClause<MangoQuery, M> {\n    return new CouchDBInsertClause({\n      statement: new CouchDBStatement(this.adapter as CouchDBAdapter),\n    });\n  }\n\n  limit(\n    statement: Statement<MangoQuery>,\n    selector: LimitSelector\n  ): LimitClause<MangoQuery> {\n    return new (class extends LimitClause<MangoQuery> {\n      constructor(clause: ModelArg<LimitClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.limit = this.selector as number;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  offset(\n    statement: Statement<MangoQuery>,\n    selector: OffsetSelector\n  ): OffsetClause<MangoQuery> {\n    return new (class extends OffsetClause<MangoQuery> {\n      constructor(clause: ModelArg<OffsetClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        const skip: number = parseInt(this.selector as unknown as string);\n        if (isNaN(skip)) throw new QueryError(\"Failed to parse offset\");\n        query.skip = skip;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  orderBy(\n    statement: Statement<MangoQuery>,\n    selector: OrderBySelector[]\n  ): OrderByClause<MangoQuery> {\n    return new (class extends OrderByClause<MangoQuery> {\n      constructor(clause: ModelArg<OrderByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.sort = query.sort || [];\n        query.selector = query.selector || ({} as MangoSelector);\n        this.selector!.forEach((s) => {\n          const [selector, value] = s;\n          const rec: any = {};\n          rec[selector] = value;\n          (query.sort as any[]).push(rec as any);\n          if (!query.selector[selector]) {\n            query.selector[selector] = {} as MangoSelector;\n            (query.selector[selector] as MangoSelector)[\n              CouchDBOperator.BIGGER\n            ] = null;\n          }\n          // query.fields = query.fields || [];\n          // query.fields = [...new Set([...query.fields, selector]).keys()]\n        });\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  select<M extends Model>(\n    selector: SelectSelector | undefined\n  ): SelectClause<MangoQuery, M> {\n    return new CouchDBSelectClause({\n      statement: new CouchDBStatement(this.adapter),\n      selector: selector,\n    });\n  }\n\n  values<M extends Model>(\n    statement: Statement<MangoQuery>,\n    values: M[]\n  ): ValuesClause<MangoQuery, M> {\n    return new CouchDBValuesClause<M>({\n      statement: statement,\n      values: values,\n    });\n  }\n\n  where(\n    statement: Statement<MangoQuery>,\n    condition: Condition\n  ): WhereClause<MangoQuery> {\n    return new CouchDBWhereClause({\n      statement: statement,\n      condition: condition,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/factory.ts"],"names":[],"mappings":"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","file":"query/factory.js","sourcesContent":["import {\n  ClauseFactory,\n  Condition,\n  FromClause,\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  QueryError,\n  SelectSelector,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { LimitClause } from \"@decaf-ts/core\";\nimport { SelectClause } from \"@decaf-ts/core\";\nimport { WhereClause } from \"@decaf-ts/core\";\nimport { OffsetClause } from \"@decaf-ts/core\";\nimport { OrderByClause } from \"@decaf-ts/core\";\nimport { GroupByClause } from \"@decaf-ts/core\";\nimport { ValuesClause } from \"@decaf-ts/core\";\nimport { InsertClause } from \"@decaf-ts/core\";\nimport { CouchDBFromClause } from \"./FromClause\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { CouchDBInsertClause } from \"./InsertClause\";\nimport { CouchDBStatement } from \"./Statement\";\nimport { CouchDBWhereClause } from \"./WhereClause\";\nimport { CouchDBSelectClause } from \"./SelectClause\";\nimport { CouchDBValuesClause } from \"./ValuesClause\";\nimport { CouchDBOperator } from \"./constants\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { DocumentScope, MangoQuery, MangoSelector } from \"../types\";\n\nexport class Factory extends ClauseFactory<DocumentScope<any>, MangoQuery> {\n  constructor(adapter: CouchDBAdapter) {\n    super(adapter);\n  }\n\n  from<M extends Model>(\n    statement: Statement<MangoQuery>,\n    selector: FromSelector<M>\n  ): FromClause<MangoQuery, M> {\n    return new CouchDBFromClause({ statement: statement, selector: selector });\n  }\n\n  groupBy(\n    statement: Statement<MangoQuery>,\n    selector: GroupBySelector\n  ): GroupByClause<MangoQuery> {\n    return new (class extends GroupByClause<MangoQuery> {\n      constructor(clause: ModelArg<GroupByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      build(query: MangoQuery): MangoQuery {\n        throw new InternalError(\"Not implemented\");\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  insert<M extends Model>(): InsertClause<MangoQuery, M> {\n    return new CouchDBInsertClause({\n      statement: new CouchDBStatement(this.adapter as CouchDBAdapter),\n    });\n  }\n\n  limit(\n    statement: Statement<MangoQuery>,\n    selector: LimitSelector\n  ): LimitClause<MangoQuery> {\n    return new (class extends LimitClause<MangoQuery> {\n      constructor(clause: ModelArg<LimitClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.limit = this.selector as number;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  offset(\n    statement: Statement<MangoQuery>,\n    selector: OffsetSelector\n  ): OffsetClause<MangoQuery> {\n    return new (class extends OffsetClause<MangoQuery> {\n      constructor(clause: ModelArg<OffsetClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        const skip: number = parseInt(this.selector as unknown as string);\n        if (isNaN(skip)) throw new QueryError(\"Failed to parse offset\");\n        query.skip = skip;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  orderBy(\n    statement: Statement<MangoQuery>,\n    selector: OrderBySelector[]\n  ): OrderByClause<MangoQuery> {\n    return new (class extends OrderByClause<MangoQuery> {\n      constructor(clause: ModelArg<OrderByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.sort = query.sort || [];\n        query.selector = query.selector || ({} as MangoSelector);\n        this.selector!.forEach((s) => {\n          const [selector, value] = s;\n          const rec: any = {};\n          rec[selector] = value;\n          (query.sort as any[]).push(rec as any);\n          if (!query.selector[selector]) {\n            query.selector[selector] = {} as MangoSelector;\n            (query.selector[selector] as MangoSelector)[\n              CouchDBOperator.BIGGER\n            ] = null;\n          }\n          // query.fields = query.fields || [];\n          // query.fields = [...new Set([...query.fields, selector]).keys()]\n        });\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  select<M extends Model>(\n    selector: SelectSelector | undefined\n  ): SelectClause<MangoQuery, M> {\n    return new CouchDBSelectClause({\n      statement: new CouchDBStatement(this.adapter),\n      selector: selector,\n    });\n  }\n\n  values<M extends Model>(\n    statement: Statement<MangoQuery>,\n    values: M[]\n  ): ValuesClause<MangoQuery, M> {\n    return new CouchDBValuesClause<M>({\n      statement: statement,\n      values: values,\n    });\n  }\n\n  where(\n    statement: Statement<MangoQuery>,\n    condition: Condition\n  ): WhereClause<MangoQuery> {\n    return new CouchDBWhereClause({\n      statement: statement,\n      condition: condition,\n    });\n  }\n}\n"]}

package/lib/esm/query/translate.d.ts

@@ -1,3 +1,3 @@
 import { GroupOperator, Operator } from "@decaf-ts/core";
-import { MangoOperator } from "nano";
+import { MangoOperator } from "../types";
 export declare function translateOperators(operator: GroupOperator | Operator): MangoOperator;

package/lib/esm/query/translate.js

@@ -9,4 +9,4 @@ export function translateOperators(operator) {
     throw new QueryError(`Could not find adapter translation for operator ${operator}`);
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS90cmFuc2xhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLGVBQWUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHNUMsTUFBTSxVQUFVLGtCQUFrQixDQUNoQyxRQUFrQztJQUVsQyxLQUFLLE1BQU0sU0FBUyxJQUFJLENBQUMsZUFBZSxFQUFFLG9CQUFvQixDQUFDLEVBQUUsQ0FBQztRQUNoRSxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLFFBQVEsQ0FBQyxDQUFDO1FBQzlELElBQUksRUFBRTtZQUFFLE9BQU8sU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQy9CLENBQUM7SUFDRCxNQUFNLElBQUksVUFBVSxDQUNsQixtREFBbUQsUUFBUSxFQUFFLENBQzlELENBQUM7QUFDSixDQUFDIiwiZmlsZSI6InF1ZXJ5L3RyYW5zbGF0ZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEdyb3VwT3BlcmF0b3IsIE9wZXJhdG9yIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBDb3VjaERCR3JvdXBPcGVyYXRvciwgQ291Y2hEQk9wZXJhdG9yIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBRdWVyeUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBNYW5nb09wZXJhdG9yIH0gZnJvbSBcIm5hbm9cIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHRyYW5zbGF0ZU9wZXJhdG9ycyhcbiAgb3BlcmF0b3I6IEdyb3VwT3BlcmF0b3IgfCBPcGVyYXRvclxuKTogTWFuZ29PcGVyYXRvciB7XG4gIGZvciAoY29uc3Qgb3BlcmF0b3JzIG9mIFtDb3VjaERCT3BlcmF0b3IsIENvdWNoREJHcm91cE9wZXJhdG9yXSkge1xuICAgIGNvbnN0IGVsID0gT2JqZWN0LmtleXMob3BlcmF0b3JzKS5maW5kKChrKSA9PiBrID09PSBvcGVyYXRvcik7XG4gICAgaWYgKGVsKSByZXR1cm4gb3BlcmF0b3JzW2VsXTtcbiAgfVxuICB0aHJvdyBuZXcgUXVlcnlFcnJvcihcbiAgICBgQ291bGQgbm90IGZpbmQgYWRhcHRlciB0cmFuc2xhdGlvbiBmb3Igb3BlcmF0b3IgJHtvcGVyYXRvcn1gXG4gICk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS90cmFuc2xhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLGVBQWUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHNUMsTUFBTSxVQUFVLGtCQUFrQixDQUNoQyxRQUFrQztJQUVsQyxLQUFLLE1BQU0sU0FBUyxJQUFJLENBQUMsZUFBZSxFQUFFLG9CQUFvQixDQUFDLEVBQUUsQ0FBQztRQUNoRSxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLFFBQVEsQ0FBQyxDQUFDO1FBQzlELElBQUksRUFBRTtZQUFFLE9BQU8sU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQy9CLENBQUM7SUFDRCxNQUFNLElBQUksVUFBVSxDQUNsQixtREFBbUQsUUFBUSxFQUFFLENBQzlELENBQUM7QUFDSixDQUFDIiwiZmlsZSI6InF1ZXJ5L3RyYW5zbGF0ZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEdyb3VwT3BlcmF0b3IsIE9wZXJhdG9yIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBDb3VjaERCR3JvdXBPcGVyYXRvciwgQ291Y2hEQk9wZXJhdG9yIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBRdWVyeUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBNYW5nb09wZXJhdG9yIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB0cmFuc2xhdGVPcGVyYXRvcnMoXG4gIG9wZXJhdG9yOiBHcm91cE9wZXJhdG9yIHwgT3BlcmF0b3Jcbik6IE1hbmdvT3BlcmF0b3Ige1xuICBmb3IgKGNvbnN0IG9wZXJhdG9ycyBvZiBbQ291Y2hEQk9wZXJhdG9yLCBDb3VjaERCR3JvdXBPcGVyYXRvcl0pIHtcbiAgICBjb25zdCBlbCA9IE9iamVjdC5rZXlzKG9wZXJhdG9ycykuZmluZCgoaykgPT4gayA9PT0gb3BlcmF0b3IpO1xuICAgIGlmIChlbCkgcmV0dXJuIG9wZXJhdG9yc1tlbF07XG4gIH1cbiAgdGhyb3cgbmV3IFF1ZXJ5RXJyb3IoXG4gICAgYENvdWxkIG5vdCBmaW5kIGFkYXB0ZXIgdHJhbnNsYXRpb24gZm9yIG9wZXJhdG9yICR7b3BlcmF0b3J9YFxuICApO1xufVxuIl19

package/lib/esm/types.d.ts

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

package/lib/esm/types.js

@@ -0,0 +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"]}

package/lib/esm/utils.d.ts

@@ -1,7 +1,7 @@
 import { OrderDirection } from "@decaf-ts/core";
-import { CreateIndexRequest, DocumentScope, ServerScope } from "nano";
-export declare function reAuth(con: ServerScope, user: string, pass: string): Promise<import("nano").DatabaseAuthResponse>;
-export declare function wrapDocumentScope(con: ServerScope, dbName: string, user: string, pass: string): DocumentScope<any>;
+import { CreateIndexRequest } from "./types";
+export declare function reAuth(con: any, user: string, pass: string): Promise<any>;
+export declare function wrapDocumentScope(con: any, dbName: string, user: string, pass: string): any;
 export declare function testReservedAttributes(attr: string): RegExpMatchArray | null;
 export declare function generateIndexName(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): string;
 export declare function generateIndexDoc(attribute: string, tableName: string, compositions?: string[], order?: OrderDirection, separator?: string): CreateIndexRequest;

package/lib/esm/utils.js

@@ -69,4 +69,4 @@ export function generateIndexDoc(attribute, tableName, compositions, order, sepa
     };
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/index.cjs

@@ -15,11 +15,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
+__exportStar(require("./indexes/index.cjs"), exports);
+__exportStar(require("./interfaces/index.cjs"), exports);
 __exportStar(require("./model/index.cjs"), exports);
 __exportStar(require("./sequences/index.cjs"), exports);
 __exportStar(require("./adapter.cjs"), exports);
 __exportStar(require("./constants.cjs"), exports);
 __exportStar(require("./errors.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
 __exportStar(require("./utils.cjs"), exports);
 /**
  * @summary Module summary
@@ -38,6 +41,6 @@ __exportStar(require("./utils.cjs"), exports);
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-exports.VERSION = "0.0.1";
+exports.VERSION = "0.0.2";
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4Qiw4Q0FBNEI7QUFDNUIsNENBQTBCO0FBQzFCLDhDQUE0QjtBQUM1QiwyQ0FBeUI7QUFDekIsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcXVlbmNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgTW9kdWxlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBNb2R1bGUgZGVzY3JpcHRpb25cbiAqIEBtb2R1bGUgdHMtd29ya3NwYWNlXG4gKi9cblxuLyoqXG4gKiBAc3VtbWFyeSBOYW1lc3BhY2Ugc3VtbWFyeVxuICogQGRlc2NyaXB0aW9uIE5hbWVzcGFjZSBkZXNjcmlwdGlvblxuICogQG5hbWVzcGFjZSBOYW1lc3BhY2VcbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cblxuLyoqXG4gKiBAc3VtbWFyeSBzdG9yZXMgdGhlIGN1cnJlbnQgcGFja2FnZSB2ZXJzaW9uXG4gKiBAZGVzY3JpcHRpb24gdGhpcyBpcyBob3cgeW91IHNob3VsZCBkb2N1bWVudCBhIGNvbnN0YW50XG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTp0cy13b3Jrc3BhY2VcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIjAuMC4xXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwrQ0FBNkI7QUFDN0IsMENBQXdCO0FBQ3hCLDhDQUE0QjtBQUM1Qiw0Q0FBMEI7QUFDMUIsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6QiwwQ0FBd0I7QUFDeEIsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vaW5kZXhlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcXVlbmNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE1vZHVsZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTW9kdWxlIGRlc2NyaXB0aW9uXG4gKiBAbW9kdWxlIHRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgTmFtZXNwYWNlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBOYW1lc3BhY2UgZGVzY3JpcHRpb25cbiAqIEBuYW1lc3BhY2UgTmFtZXNwYWNlXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5cbi8qKlxuICogQHN1bW1hcnkgc3RvcmVzIHRoZSBjdXJyZW50IHBhY2thZ2UgdmVyc2lvblxuICogQGRlc2NyaXB0aW9uIHRoaXMgaXMgaG93IHlvdSBzaG91bGQgZG9jdW1lbnQgYSBjb25zdGFudFxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIwLjAuMlwiO1xuIl19

package/lib/index.d.ts

@@ -1,8 +1,11 @@
+export * from "./indexes";
+export * from "./interfaces";
 export * from "./model";
 export * from "./sequences";
 export * from "./adapter";
 export * from "./constants";
 export * from "./errors";
+export * from "./types";
 export * from "./utils";
 /**
  * @summary Module summary
@@ -21,4 +24,4 @@ export * from "./utils";
  * @const VERSION
  * @memberOf module:ts-workspace
  */
-export declare const VERSION = "0.0.1";
+export declare const VERSION = "0.0.2";