@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/query-builder/mquery/nosql-query-builder.d.ts

@@ -0,0 +1,165 @@
+import type { MangoQuery, MangoQuerySelector, MangoQuerySortPart } from '../../../types/index.d.ts';
+declare type MQueryOptions = {
+    limit?: number;
+    skip?: number;
+    sort?: any;
+};
+export declare class NoSqlQueryBuilderClass<DocType> {
+    _path?: any | undefined;
+    options: MQueryOptions;
+    _conditions: MangoQuerySelector<DocType>;
+    _fields: any;
+    private _distinct;
+    /**
+     * MQuery constructor used for building queries.
+     *
+     * ####Example:
+     *     var query = new MQuery({ name: 'mquery' });
+     *     query.where('age').gte(21).exec(callback);
+     *
+     */
+    constructor(mangoQuery?: MangoQuery<DocType>, _path?: any | undefined);
+    /**
+     * Specifies a `path` for use with chaining.
+     */
+    where(_path: string, _val?: MangoQuerySelector<DocType>): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies the complementary comparison value for paths specified with `where()`
+     * ####Example
+     *     User.where('age').equals(49);
+     */
+    equals(val: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies the complementary comparison value for paths specified with `where()`
+     * This is alias of `equals`
+     */
+    eq(val: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies arguments for an `$or` condition.
+     * ####Example
+     *     query.or([{ color: 'red' }, { status: 'emergency' }])
+     */
+    or(array: any[]): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies arguments for a `$nor` condition.
+     * ####Example
+     *     query.nor([{ color: 'green' }, { status: 'ok' }])
+     */
+    nor(array: any[]): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies arguments for a `$and` condition.
+     * ####Example
+     *     query.and([{ color: 'green' }, { status: 'ok' }])
+     * @see $and http://docs.mongodb.org/manual/reference/operator/and/
+     */
+    and(array: any[]): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies a `$mod` condition
+     */
+    mod(_path: string, _val: number): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies an `$exists` condition
+     * ####Example
+     *     // { name: { $exists: true }}
+     *     Thing.where('name').exists()
+     *     Thing.where('name').exists(true)
+     *     Thing.find().exists('name')
+     */
+    exists(_path: string, _val: number): NoSqlQueryBuilder<DocType>;
+    /**
+     * Specifies an `$elemMatch` condition
+     * ####Example
+     *     query.elemMatch('comment', { author: 'autobot', votes: {$gte: 5}})
+     *     query.where('comment').elemMatch({ author: 'autobot', votes: {$gte: 5}})
+     *     query.elemMatch('comment', function (elem) {
+     *       elem.where('author').equals('autobot');
+     *       elem.where('votes').gte(5);
+     *     })
+     *     query.where('comment').elemMatch(function (elem) {
+     *       elem.where({ author: 'autobot' });
+     *       elem.where('votes').gte(5);
+     *     })
+     */
+    elemMatch(_path: string, _criteria: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Sets the sort order
+     * If an object is passed, values allowed are 'asc', 'desc', 'ascending', 'descending', 1, and -1.
+     * If a string is passed, it must be a space delimited list of path names.
+     * The sort order of each path is ascending unless the path name is prefixed with `-` which will be treated as descending.
+     * ####Example
+     *     query.sort({ field: 'asc', test: -1 });
+     *     query.sort('field -test');
+     *     query.sort([['field', 1], ['test', -1]]);
+     */
+    sort(arg: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Merges another MQuery or conditions object into this one.
+     *
+     * When a MQuery is passed, conditions, field selection and options are merged.
+     *
+     */
+    merge(source: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Finds documents.
+     * ####Example
+     *     query.find()
+     *     query.find({ name: 'Burning Lights' })
+     */
+    find(criteria: any): NoSqlQueryBuilder<DocType>;
+    /**
+     * Make sure _path is set.
+     *
+     * @param {String} method
+     */
+    _ensurePath(method: any): void;
+    toJSON(): {
+        query: MangoQuery<DocType>;
+        path?: string;
+    };
+}
+export declare function mQuerySortToRxDBSort<DocType>(sort: {
+    [k: string]: 1 | -1;
+}): MangoQuerySortPart<DocType>[];
+/**
+ * Because some prototype-methods are generated,
+ * we have to define the type of NoSqlQueryBuilder here
+ */
+export interface NoSqlQueryBuilder<DocType = any> extends NoSqlQueryBuilderClass<DocType> {
+    maxScan: ReturnSelfNumberFunction<DocType>;
+    batchSize: ReturnSelfNumberFunction<DocType>;
+    limit: ReturnSelfNumberFunction<DocType>;
+    skip: ReturnSelfNumberFunction<DocType>;
+    comment: ReturnSelfFunction<DocType>;
+    gt: ReturnSelfFunction<DocType>;
+    gte: ReturnSelfFunction<DocType>;
+    lt: ReturnSelfFunction<DocType>;
+    lte: ReturnSelfFunction<DocType>;
+    ne: ReturnSelfFunction<DocType>;
+    in: ReturnSelfFunction<DocType>;
+    nin: ReturnSelfFunction<DocType>;
+    all: ReturnSelfFunction<DocType>;
+    regex: ReturnSelfFunction<DocType>;
+    size: ReturnSelfFunction<DocType>;
+}
+declare type ReturnSelfFunction<DocType> = (v: any) => NoSqlQueryBuilder<DocType>;
+declare type ReturnSelfNumberFunction<DocType> = (v: number | null) => NoSqlQueryBuilder<DocType>;
+/**
+ * limit, skip, maxScan, batchSize, comment
+ *
+ * Sets these associated options.
+ *
+ *     query.comment('feed query');
+ */
+export declare const OTHER_MANGO_ATTRIBUTES: string[];
+/**
+ * gt, gte, lt, lte, ne, in, nin, all, regex, size, maxDistance
+ *
+ *     Thing.where('type').nin(array)
+ */
+export declare const OTHER_MANGO_OPERATORS: string[];
+/**
+ * Determines if `conds` can be merged using `mquery().merge()`
+ */
+export declare function canMerge(conds: any): boolean;
+export declare function createQueryBuilder<DocType>(query?: MangoQuery<DocType>, path?: any): NoSqlQueryBuilder<DocType>;
+export {};

package/dist/types/plugins/react/database-context.d.ts

@@ -0,0 +1,4 @@
+import type { RxDatabase } from '../../types/index.d.ts';
+export declare const RxDatabaseContext: import("react").Context<RxDatabase>;
+declare const Provider: import("react").Provider<RxDatabase>, Consumer: import("react").Consumer<RxDatabase>;
+export { Consumer as RxDatabaseConsumer, Provider };

package/dist/types/plugins/react/database-provider.d.ts

@@ -0,0 +1,24 @@
+import React, { type ReactElement } from 'react';
+import type { RxDatabase } from '../../types/index';
+import { Provider } from './database-context.ts';
+export type RxDatabaseProviderProps = {
+    database: RxDatabase;
+    children: React.ReactNode;
+};
+/**
+ * RxDatabaseProvider is a React context provider component for RxDB.
+ * It ensures that a valid RxDatabase instance is passed and makes it available
+ * to all descendant components via React Context.
+ *
+ * @param {RxDatabaseProviderProps} props - The provider props.
+ * @param {RxDatabase} props.database - The RxDatabase instance to provide.
+ * @param {React.ReactNode} props.children - The child components that will have access to the database.
+ * @throws {Error} If the provided database is not a valid RxDatabase instance.
+ * @returns {ReactElement} The context provider wrapping the children.
+ *
+ * @example
+ * <RxDatabaseProvider database={myDatabase}>
+ *   <MyComponent />
+ * </RxDatabaseProvider>
+ */
+export declare function RxDatabaseProvider({ children, database, }: RxDatabaseProviderProps): ReactElement<typeof Provider>;

package/dist/types/plugins/react/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './use-rx-collection.ts';
+export * from './use-rx-database.ts';
+export * from './use-rx-query.ts';
+export * from './use-live-rx-query.ts';

package/dist/types/plugins/react/hooks/use-live-rx-query.d.ts

@@ -0,0 +1,11 @@
+import { UseRxQueryOptions, UseRxQueryResult } from './use-rx-query.ts';
+/**
+ * React hook to query an RxDB collection with Mango queries.
+ *
+ * @param {UseRxQueryOptions<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity>} options - Options for the query.
+ * @param {string|RxCollection} options.collection - The collection name or instance to query.
+ * @param {MangoQuery<RxDocumentType>} options.query - The Mango query to execute.
+ *
+ * @returns {UseRxQueryResult<RxDocumentType, OrmMethods>} The query result, loading state, and error.
+ */
+export declare function useLiveRxQuery<RxDocumentType = any, OrmMethods = {}, StaticMethods = {}, InstanceCreationOptions = {}, Reactivity = unknown>({ collection, query, }: UseRxQueryOptions<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity>): UseRxQueryResult<RxDocumentType, OrmMethods>;

package/dist/types/plugins/react/hooks/use-rx-collection.d.ts

@@ -0,0 +1,10 @@
+import type { RxCollection } from '../../../types/index.d.ts';
+/**
+ * The `useRxCollection` hook retrieves an RxDB collection by name and maintains
+ * its state as the collection lifecycle changes.
+ *
+ * @param {string} name The name of the collection to retrieve.
+ * @returns The RxCollection instance or null
+ * if the collection does not exist or has been closed.
+ */
+export declare function useRxCollection<RxDocumentType = any, OrmMethods = {}, StaticMethods = {}, InstanceCreationOptions = {}, Reactivity = unknown>(name: string): RxCollection<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity> | null;

package/dist/types/plugins/react/hooks/use-rx-database.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionsOfDatabase, RxDatabase } from '../../../types/index.d.ts';
+/**
+ * The `useRxDatabase` hook retrieves the RxDB database instance from context.
+ *
+ * @returns The RxDB database instance.
+ * @throws {Error} Throws an error if the component is not wrapped in a <RxDatabaseProvider>.
+ * This ensures the database context is properly initialized before use.
+ */
+export declare function useRxDatabase<Collections = CollectionsOfDatabase, Internals = any, InstanceCreationOptions = any, Reactivity = any>(): RxDatabase<Collections, Internals, InstanceCreationOptions, Reactivity>;

package/dist/types/plugins/react/hooks/use-rx-query.d.ts

@@ -0,0 +1,24 @@
+import type { MangoQuery, RxCollection, RxDocument } from '../../../types/index.d.ts';
+export type UseRxQueryOptions<RxDocumentType = any, OrmMethods = {}, StaticMethods = {}, InstanceCreationOptions = {}, Reactivity = unknown> = {
+    collection: string | RxCollection<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity>;
+    query: MangoQuery<RxDocumentType>;
+};
+export type UseRxQueryResult<RxDocumentType = any, OrmMethods = {}> = {
+    results: RxDocument<RxDocumentType, OrmMethods>[];
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * React hook to query an RxDB collection with Mango queries.
+ *
+ * @param {UseRxQueryOptions<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity>} options - Options for the query.
+ * @param {string|RxCollection} options.collection - The collection name or instance to query.
+ * @param {MangoQuery<RxDocumentType>} options.query - The Mango query to execute.
+ * @param {boolean} [options.live] - Whether to subscribe to live query updates.
+ *
+ * @returns {UseRxQueryResult<RxDocumentType, OrmMethods>} The query result, loading state, and error.
+ */
+export declare function useRxQueryBase<RxDocumentType = any, OrmMethods = {}, StaticMethods = {}, InstanceCreationOptions = {}, Reactivity = unknown>({ collection, query, live, }: UseRxQueryOptions<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity> & {
+    live: boolean;
+}): UseRxQueryResult<RxDocumentType, OrmMethods>;
+export declare function useRxQuery<RxDocumentType = any, OrmMethods = {}, StaticMethods = {}, InstanceCreationOptions = {}, Reactivity = unknown>({ collection, query, }: UseRxQueryOptions<RxDocumentType, OrmMethods, StaticMethods, InstanceCreationOptions, Reactivity>): UseRxQueryResult<RxDocumentType, OrmMethods>;

package/dist/types/plugins/react/index.d.ts

@@ -0,0 +1,2 @@
+export { RxDatabaseProvider } from './database-provider.tsx';
+export * from './hooks/index.ts';

package/dist/types/plugins/reactivity-angular/index.d.ts

@@ -0,0 +1,16 @@
+import { Signal, Injector } from '@angular/core';
+import type { RxReactivityFactory, ReactivityLambda } from '../../types';
+/**
+ * Type-level function (ReactivityLambda) for Angular signals.
+ * Use this as the Reactivity type parameter for properly typed signals.
+ *
+ * @example
+ * const db = await createRxDatabase<MyCollections, any, any, AngularSignalReactivityLambda>({
+ *     reactivity: createReactivityFactory(injector)
+ * });
+ * const signal = doc.age$$; // Signal<number>
+ */
+export interface AngularSignalReactivityLambda extends ReactivityLambda {
+    readonly _result: Signal<this['_data']>;
+}
+export declare function createReactivityFactory(injector: Injector): RxReactivityFactory<AngularSignalReactivityLambda>;

package/dist/types/plugins/reactivity-preact-signals/index.d.ts

@@ -0,0 +1,27 @@
+import { Signal } from "@preact/signals-core";
+import type { Subscription } from 'rxjs';
+import type { RxReactivityFactory, ReactivityLambda } from '../../types/index.d.ts';
+/**
+ * Type-level function (ReactivityLambda) for Preact signals.
+ * Use this as the Reactivity type parameter for properly typed signals.
+ *
+ * @example
+ * const db = await createRxDatabase<MyCollections, any, any, PreactSignalReactivityLambda>({
+ *     reactivity: PreactSignalsRxReactivityFactory
+ * });
+ * const signal = doc.age$$; // Signal<number>
+ */
+export interface PreactSignalReactivityLambda extends ReactivityLambda {
+    readonly _result: Signal<this['_data']>;
+}
+export type PreactSignal<T = any> = Signal<T>;
+/**
+ * Exported to debug and test
+ * the behavior
+ */
+export declare const PREACT_SIGNAL_STATE: {
+    subscribeCount: number;
+    signalBySubscription: WeakMap<Subscription, PreactSignal<any>>;
+    aliveSubscription: Set<Subscription>;
+};
+export declare const PreactSignalsRxReactivityFactory: RxReactivityFactory<PreactSignalReactivityLambda>;

package/dist/types/plugins/reactivity-vue/index.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import type { RxReactivityFactory, ReactivityLambda } from '../../types';
+/**
+ * Type-level function (ReactivityLambda) for Vue refs.
+ * Use this as the Reactivity type parameter for properly typed refs.
+ *
+ * @example
+ * const db = await createRxDatabase<MyCollections, any, any, VueRefReactivityLambda>({
+ *     reactivity: VueRxReactivityFactory
+ * });
+ * const ref = doc.age$$; // Ref<number>
+ */
+export interface VueRefReactivityLambda extends ReactivityLambda {
+    readonly _result: Ref<this['_data']>;
+}
+export type VueRef<T = any> = Ref<T>;
+export declare const VueRxReactivityFactory: RxReactivityFactory<VueRefReactivityLambda>;

package/dist/types/plugins/replication/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * This plugin contains the primitives to create
+ * a RxDB client-server replication.
+ * It is used in the other replication plugins
+ * but also can be used as standalone with a custom replication handler.
+ */
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions, RxCollection, RxDocumentData, RxError, RxJsonSchema, RxReplicationPullStreamItem, RxStorageInstance, RxStorageInstanceReplicationState, RxStorageReplicationMeta, RxTypeError, WithDeleted } from '../../types/index.d.ts';
+export declare const REPLICATION_STATE_BY_COLLECTION: WeakMap<RxCollection, RxReplicationState<any, any>[]>;
+export declare class RxReplicationState<RxDocType, CheckpointType> {
+    /**
+     * The identifier, used to flag revisions
+     * and to identify which documents state came from the remote.
+     */
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType, unknown, unknown, unknown>;
+    readonly deletedField: string;
+    readonly pull?: ReplicationPullOptions<RxDocType, CheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live?: boolean | undefined;
+    retryTime?: number | undefined;
+    autoStart?: boolean | undefined;
+    toggleOnDocumentVisible?: boolean | undefined;
+    readonly subs: Subscription[];
+    readonly subjects: {
+        received: Subject<RxDocumentData<RxDocType>>;
+        sent: Subject<WithDeleted<RxDocType>>;
+        error: Subject<RxError | RxTypeError>;
+        canceled: BehaviorSubject<boolean>;
+        active: BehaviorSubject<boolean>;
+    };
+    readonly received$: Observable<RxDocumentData<RxDocType>>;
+    readonly sent$: Observable<WithDeleted<RxDocType>>;
+    readonly error$: Observable<RxError | RxTypeError>;
+    readonly canceled$: Observable<any>;
+    readonly active$: Observable<boolean>;
+    wasStarted: boolean;
+    readonly metaInfoPromise: Promise<{
+        collectionName: string;
+        schema: RxJsonSchema<RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>>;
+    }>;
+    startPromise: Promise<void>;
+    /**
+     * start/pause/cancel/remove must never run
+     * in parallel to avoid a wide range of bugs.
+     */
+    startQueue: Promise<any>;
+    onCancel: (() => void)[];
+    constructor(
+    /**
+     * The identifier, used to flag revisions
+     * and to identify which documents state came from the remote.
+     */
+    replicationIdentifier: string, collection: RxCollection<RxDocType, unknown, unknown, unknown>, deletedField: string, pull?: ReplicationPullOptions<RxDocType, CheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean | undefined, retryTime?: number | undefined, autoStart?: boolean | undefined, toggleOnDocumentVisible?: boolean | undefined);
+    private callOnStart;
+    internalReplicationState?: RxStorageInstanceReplicationState<RxDocType>;
+    metaInstance?: RxStorageInstance<RxStorageReplicationMeta<RxDocType, CheckpointType>, any, {}, any>;
+    remoteEvents$: Subject<RxReplicationPullStreamItem<RxDocType, CheckpointType>>;
+    start(): Promise<void>;
+    _start(): Promise<void>;
+    pause(): Promise<any>;
+    isPaused(): boolean;
+    isStopped(): boolean;
+    isStoppedOrPaused(): boolean;
+    awaitInitialReplication(): Promise<void>;
+    /**
+     * Returns a promise that resolves when:
+     * - All local data is replicated with the remote
+     * - No replication cycle is running or in retry-state
+     *
+     * WARNING: Using this function directly in a multi-tab browser application
+     * is dangerous because only the leading instance will ever be replicated,
+     * so this promise will not resolve in the other tabs.
+     * For multi-tab support you should set and observe a flag in a local document.
+     */
+    awaitInSync(): Promise<true>;
+    reSync(): void;
+    emitEvent(ev: RxReplicationPullStreamItem<RxDocType, CheckpointType>): void;
+    cancel(): Promise<void>;
+    _cancel(doNotClose?: boolean): Promise<any>;
+    remove(): Promise<any>;
+}
+export declare function replicateRxCollection<RxDocType, CheckpointType>({ replicationIdentifier, collection, deletedField, pull, push, live, retryTime, waitForLeadership, autoStart, toggleOnDocumentVisible }: ReplicationOptions<RxDocType, CheckpointType>): RxReplicationState<RxDocType, CheckpointType>;
+export declare function startReplicationOnLeaderShip(waitForLeadership: boolean, replicationState: RxReplicationState<any, any>): Promise<void>;

package/dist/types/plugins/replication/replication-helper.d.ts

@@ -0,0 +1,23 @@
+import type { RxCollection, WithDeleted } from '../../types/index.d.ts';
+import type { RxReplicationState } from './index.ts';
+export declare const DEFAULT_MODIFIER: (d: any) => Promise<any>;
+export declare function swapDefaultDeletedTodeletedField<RxDocType>(deletedField: string, doc: WithDeleted<RxDocType>): RxDocType;
+/**
+ * Must be run over all plain document data
+ * that was pulled from the remote.
+ * Used to fill up fields or modify the deleted field etc.
+ */
+export declare function handlePulledDocuments<RxDocType>(collection: RxCollection<RxDocType, unknown, unknown, unknown>, deletedField: string, docs: RxDocType[]): WithDeleted<RxDocType>[];
+/**
+ * Like normal promiseWait()
+ * but will skip the wait time if the online-state changes.
+ */
+export declare function awaitRetry(collection: RxCollection<any, any, any>, retryTime: number): any;
+/**
+ * When a replication is running and the leading tab get hibernated
+ * by the browser, the replication will be stuck.
+ * To prevent this, we fire a mouseeven each X seconds while the replication is not canceled.
+ *
+ * If you find a better way to prevent hibernation, please make a pull request.
+ */
+export declare function preventHibernateBrowserTab(replicationState: RxReplicationState<any, any>): void;

package/dist/types/plugins/replication-appwrite/appwrite-helpers.d.ts

@@ -0,0 +1,3 @@
+import type { WithDeleted, WithDeletedAndAttachments } from '../../types';
+export declare function appwriteDocToRxDB<RxDocType>(appwriteDoc: any, primaryKey: string, deletedField: string): WithDeleted<RxDocType>;
+export declare function rxdbDocToAppwrite<RxDocType>(rxdbDoc: WithDeletedAndAttachments<RxDocType>, primaryKey: string, deletedField: string): any;

package/dist/types/plugins/replication-appwrite/appwrite-types.d.ts

@@ -0,0 +1,16 @@
+import type { ById, ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import type { Client } from 'appwrite';
+export type AppwriteCheckpointType = {
+    updatedAt: string;
+    id: string;
+};
+export type FetchMethodType = typeof fetch;
+export type SyncOptionsAppwrite<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push' | 'deletedField'> & {
+    databaseId: string;
+    collectionId: string;
+    client: Client;
+    deletedField: string;
+    pull?: Omit<ReplicationPullOptions<RxDocType, AppwriteCheckpointType>, 'handler' | 'stream$'> & {};
+    push?: Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+};
+export type URLQueryParams = ById<string | number | undefined | boolean>;

package/dist/types/plugins/replication-appwrite/index.d.ts

@@ -0,0 +1,14 @@
+import type { SyncOptionsAppwrite, AppwriteCheckpointType } from './appwrite-types';
+import { RxReplicationState } from '../replication/index.ts';
+import type { ReplicationPullOptions, ReplicationPushOptions, RxCollection } from '../../types';
+export declare class RxAppwriteReplicationState<RxDocType> extends RxReplicationState<RxDocType, AppwriteCheckpointType> {
+    readonly replicationIdentifierHash: string;
+    readonly collection: RxCollection<RxDocType>;
+    readonly pull?: ReplicationPullOptions<RxDocType, AppwriteCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(replicationIdentifierHash: string, collection: RxCollection<RxDocType>, pull?: ReplicationPullOptions<RxDocType, AppwriteCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateAppwrite<RxDocType>(options: SyncOptionsAppwrite<RxDocType>): RxAppwriteReplicationState<RxDocType>;

package/dist/types/plugins/replication-couchdb/couchdb-helper.d.ts

@@ -0,0 +1,19 @@
+import type { RxDocumentData, StringKeys, WithDeleted } from '../../types/index.d.ts';
+import { URLQueryParams } from './couchdb-types.ts';
+export declare const COUCHDB_NEW_REPLICATION_PLUGIN_IDENTITY_PREFIX = "couchdb";
+export declare function mergeUrlQueryParams(params: URLQueryParams): string;
+export declare function couchDBDocToRxDocData<RxDocType>(primaryPath: string, couchDocData: any): WithDeleted<RxDocType>;
+export declare function couchSwapIdToPrimary<T>(primaryKey: StringKeys<RxDocumentData<T>>, docData: any): any;
+/**
+ * Swaps the primaryKey of the document
+ * to the _id property.
+ */
+export declare function couchSwapPrimaryToId<RxDocType>(primaryKey: StringKeys<RxDocumentData<RxDocType>>, docData: any): RxDocType & {
+    _id: string;
+};
+export declare function getDefaultFetch(): typeof fetch;
+/**
+ * Returns a fetch handler that contains the username and password
+ * in the Authorization header
+ */
+export declare function getFetchWithCouchDBAuthorization(username: string, password: string): typeof fetch;

package/dist/types/plugins/replication-couchdb/couchdb-types.d.ts

@@ -0,0 +1,22 @@
+import type { ById, ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+export type CouchDBCheckpointType = {
+    sequence: number;
+};
+export type FetchMethodType = typeof fetch;
+export type SyncOptionsCouchDB<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push'> & {
+    url: string;
+    /**
+     * Here you can set a custom fetch method
+     * to use http headers or credentials when doing requests.
+     */
+    fetch?: FetchMethodType;
+    pull?: Omit<ReplicationPullOptions<RxDocType, CouchDBCheckpointType>, 'handler' | 'stream$'> & {
+        /**
+         * Heartbeat time in milliseconds
+         * for the long polling of the changestream.
+         */
+        heartbeat?: number;
+    };
+    push?: Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+};
+export type URLQueryParams = ById<string | number | undefined | boolean>;

package/dist/types/plugins/replication-couchdb/index.d.ts

@@ -0,0 +1,18 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { CouchDBCheckpointType, FetchMethodType, SyncOptionsCouchDB } from './couchdb-types.ts';
+export * from './couchdb-helper.ts';
+export * from './couchdb-types.ts';
+export declare class RxCouchDBReplicationState<RxDocType> extends RxReplicationState<RxDocType, CouchDBCheckpointType> {
+    readonly url: string;
+    fetch: FetchMethodType;
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType, any, any, any>;
+    readonly pull?: ReplicationPullOptions<RxDocType, CouchDBCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(url: string, fetch: FetchMethodType, replicationIdentifier: string, collection: RxCollection<RxDocType, any, any, any>, pull?: ReplicationPullOptions<RxDocType, CouchDBCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateCouchDB<RxDocType>(options: SyncOptionsCouchDB<RxDocType>): RxCouchDBReplicationState<RxDocType>;

package/dist/types/plugins/replication-firestore/firestore-helper.d.ts

@@ -0,0 +1,10 @@
+import { QueryDocumentSnapshot, Timestamp } from 'firebase/firestore';
+import type { WithDeleted } from '../../types/index.d.ts';
+import type { GetQuery } from './firestore-types.ts';
+export declare function getFirestoreSortFieldValue(docData: any, primaryKey: string): string;
+export declare function stripServerTimestampField<RxDocType>(serverTimestampField: string, docData: RxDocType): WithDeleted<RxDocType>;
+export declare function serverTimestampToIsoString(serverTimestampField: string, docData: any): string;
+export declare function isoStringToServerTimestamp(isoString: string): Timestamp;
+export declare function firestoreRowToDocData<RxDocType>(serverTimestampField: string, primaryPath: string, row: QueryDocumentSnapshot<RxDocType>): WithDeleted<RxDocType>;
+export declare function stripPrimaryKey(primaryPath: string, docData: any): any;
+export declare function getContentByIds<RxDocType>(ids: string[], getQuery: GetQuery<RxDocType>): Promise<QueryDocumentSnapshot<RxDocType>[]>;

package/dist/types/plugins/replication-firestore/firestore-types.d.ts

@@ -0,0 +1,46 @@
+import type { MaybePromise, ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions, WithDeleted } from '../../types/index.d.ts';
+import type { CollectionReference, Firestore, QueryDocumentSnapshot, QueryFilterConstraint } from 'firebase/firestore';
+export type FirestoreCheckpointType = {
+    id: string;
+    /**
+     * Firestore internally sets the time to an object like
+     * {
+     *       "seconds": 1669807105,
+     *       "nanoseconds": 476000000
+     * }
+     * But to be able to query that, we have to use a date string
+     * like '2022-11-30T11:18:25.141Z'
+     * so we store that string instead.
+     */
+    serverTimestamp: string;
+};
+export type FirestoreCollection<RxDocType> = CollectionReference<RxDocType>;
+export type FirestoreOptions<RxDocType> = {
+    projectId: string;
+    collection: FirestoreCollection<RxDocType>;
+    database: Firestore;
+};
+export type FirestoreSyncPullOptions<RxDocType> = Omit<ReplicationPullOptions<RxDocType, FirestoreCheckpointType>, 'handler' | 'stream$'> & {
+    filter?: QueryFilterConstraint | QueryFilterConstraint[];
+};
+export type FirestoreSyncPushOptions<RxDocType> = Omit<ReplicationPushOptions<RxDocType>, 'handler'> & {
+    filter?(item: WithDeleted<RxDocType>): MaybePromise<boolean>;
+};
+export type SyncOptionsFirestore<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push'> & {
+    firestore: FirestoreOptions<RxDocType>;
+    /**
+     * In firestore it is not possible to read out
+     * the internally used write timestamp.
+     * Even if we could read it out, it is not indexed which
+     * is required for fetch 'changes-since-x'.
+     * So instead we have to rely on a custom user defined field
+     * that contains the server time which is set by firestore via serverTimestamp()
+     * IMPORTANT: The serverTimestampField MUST NOT be part of the collections RxJsonSchema!
+     * [default='serverTimestamp']
+     * @link https://groups.google.com/g/firebase-talk/c/tAmPzPei-mE
+     */
+    serverTimestampField?: string;
+    pull?: FirestoreSyncPullOptions<RxDocType>;
+    push?: FirestoreSyncPushOptions<RxDocType>;
+};
+export type GetQuery<RxDocType> = (ids: string[]) => Promise<QueryDocumentSnapshot<RxDocType>[]>;

package/dist/types/plugins/replication-firestore/index.d.ts

@@ -0,0 +1,17 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { FirestoreCheckpointType, FirestoreOptions, SyncOptionsFirestore } from './firestore-types.ts';
+export * from './firestore-helper.ts';
+export * from './firestore-types.ts';
+export declare class RxFirestoreReplicationState<RxDocType> extends RxReplicationState<RxDocType, FirestoreCheckpointType> {
+    readonly firestore: FirestoreOptions<RxDocType>;
+    readonly replicationIdentifierHash: string;
+    readonly collection: RxCollection<RxDocType>;
+    readonly pull?: ReplicationPullOptions<RxDocType, FirestoreCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(firestore: FirestoreOptions<RxDocType>, replicationIdentifierHash: string, collection: RxCollection<RxDocType>, pull?: ReplicationPullOptions<RxDocType, FirestoreCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateFirestore<RxDocType>(options: SyncOptionsFirestore<RxDocType>): RxFirestoreReplicationState<RxDocType>;

package/dist/types/plugins/replication-google-drive/document-handling.d.ts

@@ -0,0 +1,13 @@
+import { ById } from '../../types/util';
+import type { DriveFileListResponse, GoogleDriveOptionsWithDefaults } from './google-drive-types.ts';
+import { DriveStructure } from './init.ts';
+export declare function getDocumentFiles(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, docIds: string[]): Promise<DriveFileListResponse>;
+export declare function batchGetFilesMetadata(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileIds: string[]): Promise<string>;
+export declare function insertDocumentFiles<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, primaryPath: keyof RxDocType, docs: RxDocType[]): Promise<void>;
+export declare function updateDocumentFiles<DocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, primaryPath: keyof DocType, docs: DocType[], fileIdByDocId: Record<string, string>, concurrency?: number): Promise<Record<string, {
+    id: string;
+}>>;
+export declare function fetchDocumentContents<DocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileIds: string[], concurrency?: number): Promise<{
+    byId: ById<DocType>;
+    ordered: (DocType)[];
+}>;