@decaf-ts/for-couchdb 0.10.0 → 0.11.0

package/lib/types/decorators.d.cts

@@ -0,0 +1,8 @@
+import { Condition } from "@decaf-ts/core";
+import { AggregateOptions, CouchDBViewOptions } from "./views/index.cjs";
+export declare function groupBy(compositionsOrOptions?: string[] | string | CouchDBViewOptions, nameOrOptions?: string | CouchDBViewOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function count(valueOrCondition?: any | Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function sum(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function max(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function min(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function distinct(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/decorators.d.mts

@@ -0,0 +1,8 @@
+import { Condition } from "@decaf-ts/core";
+import { AggregateOptions, CouchDBViewOptions } from "./views/index.js";
+export declare function groupBy(compositionsOrOptions?: string[] | string | CouchDBViewOptions, nameOrOptions?: string | CouchDBViewOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function count(valueOrCondition?: any | Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function sum(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function max(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function min(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function distinct(conditionOrOptions?: Condition<any> | AggregateOptions, options?: AggregateOptions): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/errors.d.cts

@@ -0,0 +1,21 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when there is an issue with CouchDB indexes
+ * @summary Represents an error related to CouchDB index operations
+ * @param {string|Error} msg - The error message or Error object
+ * @class
+ * @category Errors
+ * @example
+ * // Example of using IndexError
+ * try {
+ *   // Some code that might throw an index error
+ *   throw new IndexError("Index not found");
+ * } catch (error) {
+ *   if (error instanceof IndexError) {
+ *     console.error("Index error occurred:", error.message);
+ *   }
+ * }
+ */
+export declare class IndexError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/types/errors.d.mts

@@ -0,0 +1,21 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when there is an issue with CouchDB indexes
+ * @summary Represents an error related to CouchDB index operations
+ * @param {string|Error} msg - The error message or Error object
+ * @class
+ * @category Errors
+ * @example
+ * // Example of using IndexError
+ * try {
+ *   // Some code that might throw an index error
+ *   throw new IndexError("Index not found");
+ * } catch (error) {
+ *   if (error instanceof IndexError) {
+ *     console.error("Index error occurred:", error.message);
+ *   }
+ * }
+ */
+export declare class IndexError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/types/index.d.cts

@@ -0,0 +1,28 @@
+export * from "./indexes/index.cjs";
+export * from "./repository.cjs";
+export * from "./adapter.cjs";
+export * from "./constants.cjs";
+export * from "./errors.cjs";
+export * from "./metadata.cjs";
+export * from "./decorators.cjs";
+export * from "./types.cjs";
+export * from "./utils.cjs";
+export * from "./query/index.cjs";
+export * from "./views/index.cjs";
+/**
+ * @description CouchDB adapter for Decaf.ts
+ * @summary A TypeScript adapter for CouchDB database operations, providing a seamless integration with the Decaf.ts framework. This module includes classes, interfaces, and utilities for working with CouchDB databases, including support for Mango queries, document operations, and sequence management.
+ * @module for-couchdb
+ */
+/**
+ * @description Stores the current package version
+ * @summary The version string of the for-couchdb package
+ * @const VERSION
+ */
+export declare const VERSION = "0.10.0";
+/**
+ * @description Stores the current package name
+ * @summary The version string of the for-couchdb package
+ * @const PACKAGE_NAME
+ */
+export declare const PACKAGE_NAME = "@decaf-ts/for-couchdb";

package/lib/types/index.d.mts

@@ -0,0 +1,28 @@
+export * from "./indexes/index.js";
+export * from "./repository.js";
+export * from "./adapter.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./metadata.js";
+export * from "./decorators.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./query/index.js";
+export * from "./views/index.js";
+/**
+ * @description CouchDB adapter for Decaf.ts
+ * @summary A TypeScript adapter for CouchDB database operations, providing a seamless integration with the Decaf.ts framework. This module includes classes, interfaces, and utilities for working with CouchDB databases, including support for Mango queries, document operations, and sequence management.
+ * @module for-couchdb
+ */
+/**
+ * @description Stores the current package version
+ * @summary The version string of the for-couchdb package
+ * @const VERSION
+ */
+export declare const VERSION = "0.10.0";
+/**
+ * @description Stores the current package name
+ * @summary The version string of the for-couchdb package
+ * @const PACKAGE_NAME
+ */
+export declare const PACKAGE_NAME = "@decaf-ts/for-couchdb";

package/lib/types/index.d.ts

@@ -19,7 +19,7 @@ export * from "./views";
  * @summary The version string of the for-couchdb package
  * @const VERSION
  */
-export declare const VERSION = "0.9.0";
+export declare const VERSION = "0.10.0";
 /**
  * @description Stores the current package name
  * @summary The version string of the for-couchdb package

package/lib/types/indexes/generator.d.cts

@@ -0,0 +1,51 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { CreateIndexRequest } from "../types.cjs";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description Generates CouchDB index configurations for models
+ * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+ * @template M - The model type that extends Model
+ * @param models - Array of model constructors to generate indexes for
+ * @return {CreateIndexRequest[]} Array of CouchDB index configurations
+ * @function generateIndexes
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexes
+ *   participant generateIndexName
+ *   participant Repository
+ *
+ *   Caller->>generateIndexes: models
+ *
+ *   Note over generateIndexes: Create base table index
+ *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+ *   generateIndexName-->>generateIndexes: tableName
+ *   generateIndexes->>generateIndexes: Create table index config
+ *
+ *   loop For each model
+ *     generateIndexes->>Repository: Get indexes metadata
+ *     Repository-->>generateIndexes: index metadata
+ *
+ *     loop For each index in metadata
+ *       Note over generateIndexes: Extract index properties
+ *       generateIndexes->>Repository: Get table name
+ *       Repository-->>generateIndexes: tableName
+ *
+ *       Note over generateIndexes: Define nested generate function
+ *
+ *       generateIndexes->>generateIndexes: Call generate() for default order
+ *       Note over generateIndexes: Create index name and config
+ *
+ *       alt Has directions
+ *         loop For each direction
+ *           generateIndexes->>generateIndexes: Call generate(direction)
+ *           Note over generateIndexes: Create ordered index config
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ *   generateIndexes-->>Caller: Array of index configurations
+ */
+export declare function generateIndexes<M extends Model>(models: Constructor<M>[]): CreateIndexRequest[];

package/lib/types/indexes/generator.d.mts

@@ -0,0 +1,51 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { CreateIndexRequest } from "../types.js";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description Generates CouchDB index configurations for models
+ * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+ * @template M - The model type that extends Model
+ * @param models - Array of model constructors to generate indexes for
+ * @return {CreateIndexRequest[]} Array of CouchDB index configurations
+ * @function generateIndexes
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexes
+ *   participant generateIndexName
+ *   participant Repository
+ *
+ *   Caller->>generateIndexes: models
+ *
+ *   Note over generateIndexes: Create base table index
+ *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+ *   generateIndexName-->>generateIndexes: tableName
+ *   generateIndexes->>generateIndexes: Create table index config
+ *
+ *   loop For each model
+ *     generateIndexes->>Repository: Get indexes metadata
+ *     Repository-->>generateIndexes: index metadata
+ *
+ *     loop For each index in metadata
+ *       Note over generateIndexes: Extract index properties
+ *       generateIndexes->>Repository: Get table name
+ *       Repository-->>generateIndexes: tableName
+ *
+ *       Note over generateIndexes: Define nested generate function
+ *
+ *       generateIndexes->>generateIndexes: Call generate() for default order
+ *       Note over generateIndexes: Create index name and config
+ *
+ *       alt Has directions
+ *         loop For each direction
+ *           generateIndexes->>generateIndexes: Call generate(direction)
+ *           Note over generateIndexes: Create ordered index config
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ *   generateIndexes-->>Caller: Array of index configurations
+ */
+export declare function generateIndexes<M extends Model>(models: Constructor<M>[]): CreateIndexRequest[];

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

@@ -0,0 +1 @@
+export * from "./generator.cjs";

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

@@ -0,0 +1 @@
+export * from "./generator.js";

package/lib/types/metadata.d.cts

@@ -0,0 +1,4 @@
+import { Model } from "@decaf-ts/decorator-validation";
+export declare function setMetadata<M extends Model>(model: M, metadata: any): void;
+export declare function getMetadata<M extends Model>(model: M): any;
+export declare function removeMetadata<M extends Model>(model: M): void;

package/lib/types/metadata.d.mts

@@ -0,0 +1,4 @@
+import { Model } from "@decaf-ts/decorator-validation";
+export declare function setMetadata<M extends Model>(model: M, metadata: any): void;
+export declare function getMetadata<M extends Model>(model: M): any;
+export declare function removeMetadata<M extends Model>(model: M): void;

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

@@ -0,0 +1,105 @@
+import { MaybeContextualArg, Paginator } from "@decaf-ts/core";
+import { MangoQuery } from "../types.cjs";
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBAdapter } from "../adapter.cjs";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description Paginator for ConuchDB query results
+ * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+ * @param {MangoQuery} query - The Mango query to paginate
+ * @param {number} size - The page size
+ * @param {Constructor<M>} clazz - The model constructor
+ * @class CouchDBPaginator
+ * @example
+ * // Example of using CouchDBPaginator
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const query = { selector: { type: "user" } };
+ * const paginator = new CouchDBPaginator(adapter, query, 10, User);
+ *
+ * // Get the first page
+ * const page1 = await paginator.page(1);
+ *
+ * // Get the next page
+ * const page2 = await paginator.page(2);
+ */
+export declare class CouchDBPaginator<M extends Model> extends Paginator<M, M[], MangoQuery> {
+    /**
+     * @description Creates a new CouchDBPaginator instance
+     * @summary Initializes a paginator for CouchDB query results
+     * @param {CouchDBAdapter<any, any, any, any>} adapter - The CouchDB adapter
+     * @param {MangoQuery} query - The Mango query to paginate
+     * @param {number} size - The page size
+     * @param {Constructor<M>} clazz - The model constructor
+     */
+    constructor(adapter: CouchDBAdapter<any, any, any>, query: MangoQuery, size: number, clazz: Constructor<M>);
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {MangoQuery} rawStatement - The original Mango query
+     * @return {MangoQuery} The prepared query with pagination parameters
+     */
+    protected prepare(rawStatement: MangoQuery): MangoQuery;
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination and processes the results
+     * @param {number} [page=1] - The page number to retrieve
+     * @return {Promise<R[]>} A promise that resolves to an array of results
+     * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant CouchDBPaginator
+     *   participant Adapter
+     *   participant CouchDB
+     *
+     *   Client->>CouchDBPaginator: page(pageNumber)
+     *   Note over CouchDBPaginator: Clone statement
+     *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)
+     *
+     *   alt page !== 1
+     *     CouchDBPaginator->>CouchDBPaginator: Check bookmark
+     *     alt No bookmark
+     *       CouchDBPaginator-->>Client: Throw PagingError
+     *     else Has bookmark
+     *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement
+     *     end
+     *   end
+     *
+     *   CouchDBPaginator->>Adapter: raw(statement, false)
+     *   Adapter->>CouchDB: Execute query
+     *   CouchDB-->>Adapter: Return results
+     *   Adapter-->>CouchDBPaginator: Return MangoResponse
+     *
+     *   Note over CouchDBPaginator: Process results
+     *
+     *   alt Has warning
+     *     CouchDBPaginator->>CouchDBPaginator: Log warning
+     *   end
+     *
+     *   CouchDBPaginator->>CouchDBPaginator: Check for clazz
+     *
+     *   alt No clazz
+     *     CouchDBPaginator-->>Client: Throw PagingError
+     *   else Has clazz
+     *     CouchDBPaginator->>CouchDBPaginator: Find primary key
+     *
+     *     alt Has fields in statement
+     *       CouchDBPaginator->>CouchDBPaginator: Use docs directly
+     *     else No fields
+     *       CouchDBPaginator->>CouchDBPaginator: Process each document
+     *       loop For each document
+     *         CouchDBPaginator->>CouchDBPaginator: Extract original ID
+     *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)
+     *       end
+     *     end
+     *
+     *     CouchDBPaginator->>CouchDBPaginator: Store bookmark
+     *     CouchDBPaginator->>CouchDBPaginator: Update currentPage
+     *     CouchDBPaginator-->>Client: Return results
+     *   end
+     */
+    page(page?: number | undefined, bookmark?: any, ...args: MaybeContextualArg<any>): Promise<M[]>;
+}

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

@@ -0,0 +1,105 @@
+import { MaybeContextualArg, Paginator } from "@decaf-ts/core";
+import { MangoQuery } from "../types.js";
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBAdapter } from "../adapter.js";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description Paginator for ConuchDB query results
+ * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets
+ * @template M - The model type that extends Model
+ * @template R - The result type
+ * @param {CouchDBAdapter<any, any, any>} adapter - The CouchDB adapter
+ * @param {MangoQuery} query - The Mango query to paginate
+ * @param {number} size - The page size
+ * @param {Constructor<M>} clazz - The model constructor
+ * @class CouchDBPaginator
+ * @example
+ * // Example of using CouchDBPaginator
+ * const adapter = new MyCouchDBAdapter(scope);
+ * const query = { selector: { type: "user" } };
+ * const paginator = new CouchDBPaginator(adapter, query, 10, User);
+ *
+ * // Get the first page
+ * const page1 = await paginator.page(1);
+ *
+ * // Get the next page
+ * const page2 = await paginator.page(2);
+ */
+export declare class CouchDBPaginator<M extends Model> extends Paginator<M, M[], MangoQuery> {
+    /**
+     * @description Creates a new CouchDBPaginator instance
+     * @summary Initializes a paginator for CouchDB query results
+     * @param {CouchDBAdapter<any, any, any, any>} adapter - The CouchDB adapter
+     * @param {MangoQuery} query - The Mango query to paginate
+     * @param {number} size - The page size
+     * @param {Constructor<M>} clazz - The model constructor
+     */
+    constructor(adapter: CouchDBAdapter<any, any, any>, query: MangoQuery, size: number, clazz: Constructor<M>);
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {MangoQuery} rawStatement - The original Mango query
+     * @return {MangoQuery} The prepared query with pagination parameters
+     */
+    protected prepare(rawStatement: MangoQuery): MangoQuery;
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination and processes the results
+     * @param {number} [page=1] - The page number to retrieve
+     * @return {Promise<R[]>} A promise that resolves to an array of results
+     * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant CouchDBPaginator
+     *   participant Adapter
+     *   participant CouchDB
+     *
+     *   Client->>CouchDBPaginator: page(pageNumber)
+     *   Note over CouchDBPaginator: Clone statement
+     *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)
+     *
+     *   alt page !== 1
+     *     CouchDBPaginator->>CouchDBPaginator: Check bookmark
+     *     alt No bookmark
+     *       CouchDBPaginator-->>Client: Throw PagingError
+     *     else Has bookmark
+     *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement
+     *     end
+     *   end
+     *
+     *   CouchDBPaginator->>Adapter: raw(statement, false)
+     *   Adapter->>CouchDB: Execute query
+     *   CouchDB-->>Adapter: Return results
+     *   Adapter-->>CouchDBPaginator: Return MangoResponse
+     *
+     *   Note over CouchDBPaginator: Process results
+     *
+     *   alt Has warning
+     *     CouchDBPaginator->>CouchDBPaginator: Log warning
+     *   end
+     *
+     *   CouchDBPaginator->>CouchDBPaginator: Check for clazz
+     *
+     *   alt No clazz
+     *     CouchDBPaginator-->>Client: Throw PagingError
+     *   else Has clazz
+     *     CouchDBPaginator->>CouchDBPaginator: Find primary key
+     *
+     *     alt Has fields in statement
+     *       CouchDBPaginator->>CouchDBPaginator: Use docs directly
+     *     else No fields
+     *       CouchDBPaginator->>CouchDBPaginator: Process each document
+     *       loop For each document
+     *         CouchDBPaginator->>CouchDBPaginator: Extract original ID
+     *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)
+     *       end
+     *     end
+     *
+     *     CouchDBPaginator->>CouchDBPaginator: Store bookmark
+     *     CouchDBPaginator->>CouchDBPaginator: Update currentPage
+     *     CouchDBPaginator-->>Client: Return results
+     *   end
+     */
+    page(page?: number | undefined, bookmark?: any, ...args: MaybeContextualArg<any>): Promise<M[]>;
+}

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

@@ -0,0 +1,195 @@
+import { Adapter, AdapterFlags, Condition, ContextOf, SelectSelector, Statement, UnsupportedError, ViewKind } from "@decaf-ts/core";
+import { MangoQuery, MangoSelector, ViewResponse } from "../types.cjs";
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBViewMetadata } from "../views/types.cjs";
+import { CouchDBAdapter } from "../adapter.cjs";
+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 {};