repo_description: A fast, local first, reactive Database for JavaScript Applications https://rxdb.info/
repo_topics: angular browser-database couchdb crdt database firebase graphql indexeddb ionic local-first localstorage nodejs nosql postgres pouchdb react-native realtime realtime-database rxdb sqlite
code: import type {
      MangoQuery,
      MangoQuerySelector,
      MangoQuerySortPart
  } from './rx-query.d.ts';
  import type { BulkWriteRow } from './rx-storage.d.ts';
  
  /**
   * This file contains types that are CouchDB specific
   */
  
  export interface CouchReplicationOptions {
      live?: boolean;
      retry?: boolean;
      filter?: Function;
      doc_ids?: string[];
      query_params?: any;
      view?: any;
      since?: number | 'now';
      heartbeat?: number;
      timeout?: number;
      batch_size?: number;
      batches_limit?: number;
      back_off_function?: Function;
      checkpoint?: false | 'source' | 'target';
      include_docs?: boolean;
      limit?: number;
  }
  
  export interface CouchChangesOptionsBase {
      include_docs?: boolean;
      conflicts?: boolean;
      attachments?: boolean;
      binary?: boolean;
      descending?: boolean;
      since?: any;
      limit?: number;
      timeout?: any;
      heartbeat?: number | boolean;
      filter?: any;
      doc_ids?: string | string[];
      query_param?: any;
      view?: any;
      return_docs?: boolean;
      batch_size?: number;
      style?: string;
  }
  
  export interface CouchChangesOptionsLive extends CouchChangesOptionsBase {
      live: true;
  }
  
  export interface CouchChangesOptionsNonLive extends CouchChangesOptionsBase {
      live: false;
  }
  interface CouchChangesOnChangeEvent {
      on: (eventName: string, handler: Function) => void;
      off: (eventName: string, handler: Function) => void;
      cancel(): void;
  }
  
  export type CouchWriteError = {
      /**
        * status code from couchdb
        * 409 for 'conflict'
      */
      status: number;
      error: true;
      /**
       * primary key value of the errored document
       */
      id: string;
  };
  
  /**
   * possible couch-settings
   * @link https://couchdb.com/api.html#create_database
   */
  export interface CouchSettings {
      auto_compaction?: boolean;
      revs_limit?: number;
      ajax?: any;
      fetch?: any;
      auth?: any;
      skip_setup?: boolean;
      storage?: any;
      size?: number;
      location?: string;
      iosDatabaseLocation?: string;
  }
  
  /**
   * options for couch.allDocs()
   * @link https://couchdb.com/api.html#batch_fetch
   */
  export type CouchAllDocsOptions = {
      include_docs?: boolean;
      conflicts?: boolean;
      attachments?: boolean;
      binary?: boolean;
      startkey?: string;
      endkey?: string;
      inclusive_end?: boolean;
      limit?: number;
      skip?: number;
      descending?: boolean;
      key?: string;
      keys?: string[];
      update_seq?: string;
  
      // undocument but needed
      revs?: boolean;
      deleted?: 'ok';
  };
  
  export type CouchSyncHandlerEvents = 'change' | 'paused' | 'active' | 'error' | 'complete';
  export type CouchSyncHandler = {
      on(ev: CouchSyncHandlerEvents, fn: (el: any) => void): void;
      off(ev: CouchSyncHandlerEvents, fn: any): void;
      cancel(): void;
  };
  
  export type CouchChangeRow = {
      id: string;
      seq: number;
      deleted?: true;
      changes: {
          rev: 'string';
      }[];
      /**
       * only if include_docs === true
       */
      doc?: CouchChangeDoc;
  };
  
  export type CouchAttachmentMeta = {
      digest: string;
      content_type: string;
      length: number;
      stub: boolean;
  
      /**
       * 'revpos indicates the generation number (numeric prefix in the revID) at which the attachment was last altered'
       *  @link https://github.com/couchbase/couchbase-lite-ios/issues/1200#issuecomment-[REDACTED_SSN]
       */
      revpos: number;
  };
  
  export type CouchAttachmentWithData = CouchAttachmentMeta & {
      /**
       * Base64 string with the data
       * or directly a buffer
       */
      data: Blob;
      type: string;
      /**
       * If set, must be false
       * because we have the full data and not only a stub.
       */
      stub?: false;
  };
  
  export type CouchChangeDoc = {
      _id: string;
      _rev: string;
      /**
       * True if the document is deleted.
       */
      _deleted?: boolean;
      _attachments: {
          [attachmentId: string]: CouchAttachmentMeta;
      };
  };
  
  export type WithAttachments<Data> = Data & {
      /**
       * Intentional optional,
       * if the document has no attachments,
       * we do NOT have an empty object.
       */
      _attachments?: {
          [attachmentId: string]: CouchAttachmentMeta;
      };
  };
  export type WithAttachmentsData<Data> = Data & {
      /**
       * Intentional optional,
       * if the document has no attachments,
       * we do NOT have an empty object.
       */
      _attachments?: {
          [attachmentId: string]: CouchAttachmentWithData;
      };
  };
  
  
  export type WithCouchMeta<Data> = Data & {
      _rev: string;
      _attachments?: {
          [attachmentId: string]: CouchAttachmentMeta;
      };
      _deleted?: boolean;
  };
  
  export type CouchdbChangesResult = {
      results: CouchChangeRow[];
      last_seq: number;
  };
  
  declare type Debug = {
      enable(what: string): void;
      disable(): void;
  };
  
  export type CouchDbSorting = (string | string[] | { [k: string]: 'asc' | 'desc' | 1 | -1; })[];
  
  // this is not equal to the standard MangoQuery
  // because of different sorting
  export type CouchdbQuery = MangoQuery & {
      sort?: CouchDbSorting;
  };
  
  export type CouchBulkDocResultRow = {
      ok: boolean;
      id: string;
      rev: string;
  
      error?: 'conflict';
      reason?: string;
  };
  
  export type CouchCheckpoint = {
      sequence: number;
  };
  
  export type CouchBulkDocOptions = {
      new_edits?: boolean;
  
      // custom options for RxDB
      isDeeper?: boolean;
      custom?: {
          primaryPath: string;
          writeRowById: Map<string, BulkWriteRow<any>>;
          insertDocsById: Map<string, any>;
          previousDocsInDb: Map<string, any>;
          context: string;
      };
  };
  
  export type CouchMangoQuery<DocType> = MangoQuery<DocType> & {
      index: undefined;
      use_index?: string;
  };
  
  export type ExplainedCouchQuery<DocType> = {
      dbname: string;
      index: {
          ddoc: string | null;
          name: string; // 'idx-rxdb-index-age,_id'
          type: 'json';
          def: {
              fields: MangoQuerySortPart<DocType>[];
          };
      };
      selector: MangoQuerySelector<DocType>;
      range: {
          start_key: any[];
          end_key: any[];
      };
      opts: {
          use_index: string[];
          bookmark: string;
          sort: MangoQuerySortPart<DocType>[];
          conflicts: boolean;
          r: any[];
      };
      skip: number;
  };
  
  export type CouchAllDocsResponse = {
      offset: number;
      rows: {
          id: string;
          doc: any;
          key: string;
          value: {
              rev: string;
              deleted?: boolean;
          };
          error?: 'not_found' | string;
      }[];
      total_rows: number;
  };
  