@decaf-ts/for-couchdb 0.10.0 → 0.12.0

package/lib/types/query/Statement.d.mts

@@ -0,0 +1,195 @@
+import { Adapter, AdapterFlags, Condition, ContextOf, SelectSelector, Statement, UnsupportedError, ViewKind } from "@decaf-ts/core";
+import { MangoQuery, MangoSelector, ViewResponse } from "../types.js";
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBViewMetadata } from "../views/types.js";
+import { CouchDBAdapter } from "../adapter.js";
+type CouchDBViewDescriptor = {
+    ddoc: string;
+    view: string;
+    options: Record<string, any>;
+};
+type CouchDBAggregateInfo = {
+    kind: ViewKind;
+    meta: CouchDBViewMetadata;
+    descriptor: CouchDBViewDescriptor;
+    countDistinct?: boolean;
+} | {
+    kind: "avg";
+    attribute: string;
+    sumDescriptor: CouchDBViewDescriptor;
+    countDescriptor: CouchDBViewDescriptor;
+};
+/**
+ * @description Statement builder for CouchDB Mango queries
+ * @summary Provides a fluent interface for building CouchDB Mango queries with type safety
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param adapter - The CouchDB adapter
+ * @class CouchDBStatement
+ * @example
+ * // Example of using CouchDBStatement
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const statement = new CouchDBStatement<User, User[]>(adapter);
+ *
+ * // Build a query
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
+export declare class CouchDBStatement<M extends Model, A extends Adapter<any, any, MangoQuery, any>, R> extends Statement<M, A, R, MangoQuery> {
+    protected manualAggregation?: CouchDBAggregateInfo;
+    protected attributeTypeCache: Map<string, string | undefined>;
+    constructor(adapter: A, overrides?: Partial<AdapterFlags>);
+    /**
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     * @return {MangoQuery} The built Mango query
+     * @throws {Error} If there are invalid query conditions
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize selectors
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add fields to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed condition
+     *
+     *     alt Is group operator
+     *       alt Is AND operator
+     *         Statement->>Statement: Flatten nested AND conditions
+     *       else Is OR operator
+     *         Statement->>Statement: Combine with table condition
+     *       else
+     *         Statement->>Statement: Throw error
+     *       end
+     *     else
+     *       Statement->>Statement: Merge conditions with existing selector
+     *     end
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add sort to query
+     *     Statement->>Statement: Ensure field exists in selector
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set skip
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    protected build(): MangoQuery;
+    protected attachDefaultQueryIndex(query: MangoQuery): void;
+    protected collectStartsWithRangeAttrs(selector: MangoSelector): Set<string>;
+    /**
+     * @description Processes a record from CouchDB
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     * @param {any} r - The raw record from CouchDB
+     * @param pkAttr - The primary key attribute of the model
+     * @param {"Number" | "BigInt" | undefined} sequenceType - The type of the sequence
+     * @return {any} The processed record
+     */
+    protected processRecord(record: any, ctx: ContextOf<A>): M;
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to CouchDB and processes the results
+     * @template R - The result type
+     * @param {MangoQuery} rawInput - The raw Mango query to execute
+     * @return {Promise<R>} A promise that resolves to the query results
+     */
+    raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R>;
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {MangoQuery} The Mango query with the parsed condition as its selector
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant merge
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB operator
+     *     Statement->>Statement: Create selector with attribute and operator
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>translateOperators: translateOperators(Operator.NOT)
+     *     translateOperators-->>Statement: Return CouchDB NOT operator
+     *     Statement->>Statement: Create negated selector
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return CouchDB group operator
+     *     Statement->>merge: merge(operator, op1, op2)
+     *     merge-->>Statement: Return merged selector
+     *   end
+     *
+     *   Statement-->>Statement: Return query with selector
+     */
+    protected buildAggregateInfo(): CouchDBAggregateInfo | undefined;
+    protected createAggregateDescriptor(kind: ViewKind, attribute?: string): Extract<CouchDBAggregateInfo, {
+        kind: ViewKind;
+    }> | undefined;
+    protected createAggregateQuery(info: CouchDBAggregateInfo): MangoQuery & {
+        aggregate: true;
+        aggregateInfo: CouchDBAggregateInfo;
+    };
+    protected shouldUseManualAggregation(): boolean;
+    protected executeAggregate<R>(info: CouchDBAggregateInfo, ctx: ContextOf<A>): Promise<R>;
+    protected handleAverage<R>(info: CouchDBAggregateInfo, ctx: ContextOf<A>): Promise<R>;
+    protected executeManualAggregation<R>(docs: any[], info: CouchDBAggregateInfo, ctx: ContextOf<A>): R;
+    protected computeCount<R>(docs: any[], attribute?: string): R;
+    protected computeDistinctCount<R>(docs: any[], attribute?: string): R;
+    protected computeDistinctValues<R>(docs: any[], attribute?: string): R;
+    protected computeSum<R>(docs: any[], attribute?: string): R;
+    protected computeAverage<R>(docs: any[], attribute?: string): R;
+    protected computeMinMax<R>(docs: any[], attribute: string | undefined, mode: "min" | "max"): R;
+    protected computeGroupBy<R>(docs: any[], attribute: string): R;
+    protected groupSelectResults(docs: any[]): Record<string, any[]>;
+    protected collectValues(docs: any[], attribute: string): any[];
+    protected convertValueByAttribute(attribute: string, value: any): any;
+    protected getAttributeType(attribute?: string): string | undefined;
+    protected normalizeMetaType(metaType: any): string | undefined;
+    protected normalizeComparable(value: any): number | null;
+    protected groupKey(value: any): string;
+    protected toNumericValue(value: any, field: string, context: string): number;
+    protected convertAggregateValue(attribute: string | undefined, value: any): any;
+    protected resolveSelectorAttribute(selector?: SelectSelector<M> | null): string | undefined;
+    protected missingDecorator(kind: ViewKind | "avg", attribute?: string): UnsupportedError;
+    protected decoratorForKind(kind: ViewKind | "avg"): string;
+    protected processViewResponse<R>(info: CouchDBAggregateInfo, response: ViewResponse): R;
+    protected isViewAggregate(info: CouchDBAggregateInfo): info is Extract<CouchDBAggregateInfo, {
+        kind: ViewKind;
+    }>;
+    protected getCouchAdapter(): CouchDBAdapter<any, any, any>;
+    protected parseCondition(condition: Condition<M>): MangoQuery;
+}
+export {};

package/lib/types/query/constants.d.cts

@@ -0,0 +1,47 @@
+import { MangoOperator } from "../types.cjs";
+/**
+ * @description Default query limit for CouchDB queries
+ * @summary Maximum number of documents to return in a single query
+ * @const CouchDBQueryLimit
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBQueryLimit = 250;
+/**
+ * @description Mapping of operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB comparison operators used in Mango queries
+ * @typedef {Object} CouchDBOperatorType
+ * @property {string} EQUAL - Equality operator ($eq)
+ * @property {string} DIFFERENT - Inequality operator ($ne)
+ * @property {string} BIGGER - Greater than operator ($gt)
+ * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
+ * @property {string} SMALLER - Less than operator ($lt)
+ * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
+ * @property {string} NOT - Negation operator ($not)
+ * @property {string} IN - In array operator ($in)
+ * @property {string} REGEXP - Regular expression operator ($regex)
+ * @const CouchDBOperator
+ * @type {CouchDBOperatorType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBOperator: Record<string, MangoOperator>;
+/**
+ * @description Mapping of logical operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB logical operators used in Mango queries
+ * @typedef {Object} CouchDBGroupOperatorType
+ * @property {string} AND - Logical AND operator ($and)
+ * @property {string} OR - Logical OR operator ($or)
+ * @const CouchDBGroupOperator
+ * @type {CouchDBGroupOperatorType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBGroupOperator: Record<string, MangoOperator>;
+/**
+ * @description Special constant values used in CouchDB queries
+ * @summary String constants representing special values in CouchDB
+ * @typedef {Object} CouchDBConstType
+ * @property {string} NULL - String representation of null value
+ * @const CouchDBConst
+ * @type {CouchDBConstType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBConst: Record<string, string>;

package/lib/types/query/constants.d.mts

@@ -0,0 +1,47 @@
+import { MangoOperator } from "../types.js";
+/**
+ * @description Default query limit for CouchDB queries
+ * @summary Maximum number of documents to return in a single query
+ * @const CouchDBQueryLimit
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBQueryLimit = 250;
+/**
+ * @description Mapping of operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB comparison operators used in Mango queries
+ * @typedef {Object} CouchDBOperatorType
+ * @property {string} EQUAL - Equality operator ($eq)
+ * @property {string} DIFFERENT - Inequality operator ($ne)
+ * @property {string} BIGGER - Greater than operator ($gt)
+ * @property {string} BIGGER_EQ - Greater than or equal operator ($gte)
+ * @property {string} SMALLER - Less than operator ($lt)
+ * @property {string} SMALLER_EQ - Less than or equal operator ($lte)
+ * @property {string} NOT - Negation operator ($not)
+ * @property {string} IN - In array operator ($in)
+ * @property {string} REGEXP - Regular expression operator ($regex)
+ * @const CouchDBOperator
+ * @type {CouchDBOperatorType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBOperator: Record<string, MangoOperator>;
+/**
+ * @description Mapping of logical operator names to CouchDB Mango query operators
+ * @summary Constants for CouchDB logical operators used in Mango queries
+ * @typedef {Object} CouchDBGroupOperatorType
+ * @property {string} AND - Logical AND operator ($and)
+ * @property {string} OR - Logical OR operator ($or)
+ * @const CouchDBGroupOperator
+ * @type {CouchDBGroupOperatorType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBGroupOperator: Record<string, MangoOperator>;
+/**
+ * @description Special constant values used in CouchDB queries
+ * @summary String constants representing special values in CouchDB
+ * @typedef {Object} CouchDBConstType
+ * @property {string} NULL - String representation of null value
+ * @const CouchDBConst
+ * @type {CouchDBConstType}
+ * @memberOf module:for-couchdb
+ */
+export declare const CouchDBConst: Record<string, string>;

package/lib/types/query/index.d.cts

@@ -0,0 +1,4 @@
+export * from "./constants.cjs";
+export * from "./Paginator.cjs";
+export * from "./Statement.cjs";
+export * from "./translate.cjs";

package/lib/types/query/index.d.mts

@@ -0,0 +1,4 @@
+export * from "./constants.js";
+export * from "./Paginator.js";
+export * from "./Statement.js";
+export * from "./translate.js";

package/lib/types/query/translate.d.cts

@@ -0,0 +1,34 @@
+import { GroupOperator, Operator } from "@decaf-ts/core";
+import { MangoOperator } from "../types.cjs";
+/**
+ * @description Translates core operators to CouchDB Mango operators
+ * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
+ * @param {GroupOperator | Operator} operator - The core operator to translate
+ * @return {MangoOperator} The equivalent CouchDB Mango operator
+ * @throws {QueryError} If no translation exists for the given operator
+ * @function translateOperators
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant CouchDBOperator
+ *   participant CouchDBGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>CouchDBOperator: Check for match
+ *   alt Found in CouchDBOperator
+ *     CouchDBOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return MangoOperator
+ *   else Not found
+ *     translateOperators->>CouchDBGroupOperator: Check for match
+ *     alt Found in CouchDBGroupOperator
+ *       CouchDBGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return MangoOperator
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
+export declare function translateOperators(operator: GroupOperator | Operator): MangoOperator;

package/lib/types/query/translate.d.mts

@@ -0,0 +1,34 @@
+import { GroupOperator, Operator } from "@decaf-ts/core";
+import { MangoOperator } from "../types.js";
+/**
+ * @description Translates core operators to CouchDB Mango operators
+ * @summary Converts Decaf.ts core operators to their equivalent CouchDB Mango query operators
+ * @param {GroupOperator | Operator} operator - The core operator to translate
+ * @return {MangoOperator} The equivalent CouchDB Mango operator
+ * @throws {QueryError} If no translation exists for the given operator
+ * @function translateOperators
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant CouchDBOperator
+ *   participant CouchDBGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>CouchDBOperator: Check for match
+ *   alt Found in CouchDBOperator
+ *     CouchDBOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return MangoOperator
+ *   else Not found
+ *     translateOperators->>CouchDBGroupOperator: Check for match
+ *     alt Found in CouchDBGroupOperator
+ *       CouchDBGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return MangoOperator
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
+export declare function translateOperators(operator: GroupOperator | Operator): MangoOperator;

package/lib/types/repository.d.cts

@@ -0,0 +1,39 @@
+import { MaybeContextualArg, Repository } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import type { CouchDBAdapter } from "./adapter.cjs";
+import { ContextOf } from "@decaf-ts/core";
+import type { PrimaryKeyType } from "@decaf-ts/db-decorators";
+export declare class CouchDBRepository<M extends Model, A extends CouchDBAdapter<any, any, any>> extends Repository<M, A> {
+    constructor(adapter: A, model: Constructor<M>, force?: boolean);
+    protected assignMetadata(model: M, source?: M): M;
+    protected assignMetadata(models: M[], source?: M[]): M[];
+    create(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    read(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    readAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    update(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    updateAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    delete(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    deleteAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    /**
+     * @description Prepares a model for update.
+     * @summary Validates the model and prepares it for update in the database.
+     * @param {M} model - The model to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared model and context arguments.
+     * @throws {InternalError} If the model has no primary key value.
+     * @throws {ValidationError} If the model fails validation.
+     */
+    protected updatePrefix(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M, ...args: any[], ContextOf<A>, M | undefined]>;
+    /**
+     * @description Prepares multiple models for update.
+     * @summary Validates multiple models and prepares them for update in the database.
+     * @param {M[]} models - The models to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<any[]>} The prepared models and context arguments.
+     * @throws {InternalError} If any model has no primary key value.
+     * @throws {ValidationError} If any model fails validation.
+     */
+    protected updateAllPrefix(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M[], ...args: any[], ContextOf<A>, M[] | undefined]>;
+}

package/lib/types/repository.d.mts

@@ -0,0 +1,39 @@
+import { MaybeContextualArg, Repository } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import type { CouchDBAdapter } from "./adapter.js";
+import { ContextOf } from "@decaf-ts/core";
+import type { PrimaryKeyType } from "@decaf-ts/db-decorators";
+export declare class CouchDBRepository<M extends Model, A extends CouchDBAdapter<any, any, any>> extends Repository<M, A> {
+    constructor(adapter: A, model: Constructor<M>, force?: boolean);
+    protected assignMetadata(model: M, source?: M): M;
+    protected assignMetadata(models: M[], source?: M[]): M[];
+    create(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    read(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    readAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    update(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    updateAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    delete(id: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    deleteAll(ids: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    /**
+     * @description Prepares a model for update.
+     * @summary Validates the model and prepares it for update in the database.
+     * @param {M} model - The model to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared model and context arguments.
+     * @throws {InternalError} If the model has no primary key value.
+     * @throws {ValidationError} If the model fails validation.
+     */
+    protected updatePrefix(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M, ...args: any[], ContextOf<A>, M | undefined]>;
+    /**
+     * @description Prepares multiple models for update.
+     * @summary Validates multiple models and prepares them for update in the database.
+     * @param {M[]} models - The models to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<any[]>} The prepared models and context arguments.
+     * @throws {InternalError} If any model has no primary key value.
+     * @throws {ValidationError} If any model fails validation.
+     */
+    protected updateAllPrefix(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M[], ...args: any[], ContextOf<A>, M[] | undefined]>;
+}

package/lib/types/types.d.cts

@@ -0,0 +1,166 @@
+/**
+ * @description Response from a CouchDB Mango query
+ * @summary Contains the matching documents and additional metadata about the query execution
+ * @interface MangoResponse
+ * @template D - The document type
+ * @memberOf module:for-couchdb
+ * @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;
+}
+/**
+ * @description Statistics about the execution of a Mango query
+ * @summary Provides detailed metrics about query execution including document and key examination counts
+ * @interface MangoExecutionStats
+ * @memberOf module:for-couchdb
+ * @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;
+}
+/**
+ * @description Parameters for creating a CouchDB Mango index
+ * @summary Defines the structure and configuration for a new Mango index
+ * @interface CreateIndexRequest
+ * @memberOf module:for-couchdb
+ * @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;
+}
+/**
+ * @description Represents the possible value types in a Mango query
+ * @summary Union type of all possible value types that can be used in Mango queries
+ * @typedef {(number|string|Date|boolean|object|null)} MangoValue
+ * @memberOf module:for-couchdb
+ */
+export type MangoValue = number | string | Date | boolean | object | null;
+/**
+ * @description Operators available in Mango queries
+ * @summary Union type of all possible operators that can be used in Mango queries
+ * @typedef {string} MangoOperator
+ * @memberOf module:for-couchdb
+ */
+export type MangoOperator = "$lt" | "$lte" | "$eq" | "$ne" | "$gte" | "$gt" | "$exists" | "$type" | "$in" | "$nin" | "$size" | "$mod" | "$regex" | "$or" | "$and" | "$nor" | "$not" | "$all" | "$allMatch" | "$elemMatch";
+/**
+ * @description Represents a CouchDB Mango query selector
+ * @summary Type for defining query conditions in Mango queries
+ * @typedef {Object} MangoSelector
+ * @memberOf module:for-couchdb
+ * @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[];
+};
+/**
+ * @description Represents a sort order specification in Mango queries
+ * @summary Type for defining sort order in Mango queries
+ * @typedef {(string|string[]|Object)} SortOrder
+ * @memberOf module:for-couchdb
+ * @see Docs: {@link http://docs.couchdb.org/en/latest/api/database/find.html#sort-syntax}
+ */
+export type SortOrder = string | string[] | {
+    [key: string]: "asc" | "desc";
+};
+/**
+ * @description Represents a CouchDB Mango query
+ * @summary Interface for defining complete Mango queries with selectors, sorting, pagination, and other options
+ * @interface MangoQuery
+ * @memberOf module:for-couchdb
+ * @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;
+}
+export interface ViewRow<D = any> {
+    id?: string;
+    key?: any;
+    value?: any;
+    doc?: D;
+}
+export interface ViewResponse<D = any> {
+    total_rows?: number;
+    offset?: number;
+    rows: ViewRow<D>[];
+}