@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/replication-microsoft-onedrive/transaction.d.ts

@@ -0,0 +1,22 @@
+import type { OneDriveState } from './microsoft-onedrive-types.ts';
+import { DriveStructure } from './init.ts';
+export type DriveTransaction = {
+    etag: string;
+};
+export type TransactionFileContent = {
+    createdAtClientTime: number;
+};
+export declare const TRANSACTION_FILE_NAME = "transaction.json";
+export declare const TRANSACTION_BLOCKED_FLAG: {
+    readonly retry: true;
+};
+export declare function startTransactionTryOnce(oneDriveState: OneDriveState, init: DriveStructure): Promise<typeof TRANSACTION_BLOCKED_FLAG | DriveTransaction>;
+export declare function startTransaction(oneDriveState: OneDriveState, init: DriveStructure): Promise<DriveTransaction>;
+export declare function isTransactionTimedOut(oneDriveState: OneDriveState, init: DriveStructure): Promise<{
+    timeLeft: number;
+    transactionAge: number;
+    expired: boolean;
+    etag: any;
+}>;
+export declare function commitTransaction(oneDriveState: OneDriveState, init: DriveStructure, transactionInput: DriveTransaction | typeof TRANSACTION_BLOCKED_FLAG): Promise<void>;
+export declare function runInTransaction<T>(oneDriveState: OneDriveState, init: DriveStructure, primaryPath: string, fn: () => Promise<T>, runAfter?: () => any): Promise<T>;

package/dist/types/plugins/replication-microsoft-onedrive/upstream.d.ts

@@ -0,0 +1,25 @@
+import { RxReplicationWriteToMasterRow, WithDeletedAndAttachments } from '../../index.ts';
+import type { OneDriveState } from './microsoft-onedrive-types.ts';
+import { DriveStructure } from './init.ts';
+export declare const WAL_FILE_NAME = "rxdb-wal.json";
+export declare const DRIVE_MAX_BULK_SIZE = 250;
+export declare function fetchConflicts<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure, primaryPath: keyof WithDeletedAndAttachments<RxDocType>, writeRows: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<{
+    conflicts: WithDeletedAndAttachments<RxDocType>[];
+    nonConflicts: RxReplicationWriteToMasterRow<RxDocType>[];
+}>;
+export declare function writeToWal<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure, writeRows?: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<void>;
+export declare function readWalContent<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure): Promise<{
+    etag: string;
+    rows: RxReplicationWriteToMasterRow<RxDocType>[] | undefined;
+}>;
+/**
+ * Here we read the WAL file content
+ * and sort the content into the actual
+ * document files.
+ * Notice that when the JavaScript process
+ * exists at any point here, we need to have
+ * a recoverable state on the next run. So this
+ * must be idempotent.
+ */
+export declare function processWalFile<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure, primaryPath: keyof RxDocType): Promise<void>;
+export declare function handleUpstreamBatch<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure, primaryPath: keyof WithDeletedAndAttachments<RxDocType>, writeRows: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<WithDeletedAndAttachments<RxDocType>[]>;

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

@@ -0,0 +1,22 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions, RxDocumentData } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { MongoDbCheckpointType, SyncOptionsMongoDB } from './mongodb-types.ts';
+import { Db as MongoDatabase, Collection as MongoCollection, MongoClient } from 'mongodb';
+export * from './mongodb-helper.ts';
+export * from './mongodb-checkpoint.ts';
+export type * from './mongodb-types.ts';
+export declare class RxMongoDBReplicationState<RxDocType> extends RxReplicationState<RxDocType, MongoDbCheckpointType> {
+    readonly mongoClient: MongoClient;
+    readonly mongoDatabase: MongoDatabase;
+    readonly mongoCollection: MongoCollection<RxDocumentData<RxDocType> | any>;
+    readonly options: SyncOptionsMongoDB<RxDocType>;
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType, any, any>;
+    readonly pull?: ReplicationPullOptions<RxDocType, MongoDbCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(mongoClient: MongoClient, mongoDatabase: MongoDatabase, mongoCollection: MongoCollection<RxDocumentData<RxDocType> | any>, options: SyncOptionsMongoDB<RxDocType>, replicationIdentifier: string, collection: RxCollection<RxDocType, any, any>, pull?: ReplicationPullOptions<RxDocType, MongoDbCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateMongoDB<RxDocType>(options: SyncOptionsMongoDB<RxDocType>): RxMongoDBReplicationState<RxDocType>;

package/dist/types/plugins/replication-mongodb/mongodb-checkpoint.d.ts

@@ -0,0 +1,15 @@
+import { WithDeleted } from '../../types/rx-storage';
+import type { MongoDBChangeStreamResumeToken, MongoDBCheckpointIterationState, MongoDbCheckpointType } from './mongodb-types';
+import { Collection as MongoCollection } from 'mongodb';
+export declare function getCurrentResumeToken(mongoCollection: MongoCollection): Promise<MongoDBChangeStreamResumeToken>;
+export declare function getDocsSinceChangestreamCheckpoint<MongoDocType>(primaryPath: string, mongoCollection: MongoCollection, 
+/**
+ * MongoDB has no way to start the stream from 'timestamp zero',
+ * we always need a resumeToken
+ */
+resumeToken: MongoDBChangeStreamResumeToken, limit: number): Promise<{
+    docs: WithDeleted<MongoDocType>[];
+    nextToken: MongoDBChangeStreamResumeToken;
+}>;
+export declare function getDocsSinceDocumentCheckpoint<MongoDocType>(primaryPath: string, mongoCollection: MongoCollection, limit: number, checkpointId?: string): Promise<WithDeleted<MongoDocType>[]>;
+export declare function iterateCheckpoint<MongoDocType>(primaryPath: string, mongoCollection: MongoCollection, limit: number, checkpoint?: MongoDbCheckpointType): Promise<MongoDBCheckpointIterationState<MongoDocType>>;

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

@@ -0,0 +1,13 @@
+import { Subject } from 'rxjs';
+import { RxError, RxTypeError } from '../../rx-error.ts';
+import type { MongoDBChangeStreamResumeToken } from './mongodb-types';
+import { Collection as MongoCollection, ChangeStream, WithId } from 'mongodb';
+import type { RxDocumentData, WithDeleted } from '../../types/rx-storage';
+export declare function startChangeStream(mongoCollection: MongoCollection<any>, resumeToken?: MongoDBChangeStreamResumeToken, errorSubject?: Subject<RxError | RxTypeError>): Promise<ChangeStream>;
+export declare function mongodbDocToRxDB<DocType>(primaryPath: string, doc: WithId<DocType>): WithDeleted<DocType>;
+/**
+ * MongoDB operations like mongoCollection.updateOne() will mutate the input!
+ * So we have to flat-clone first here.
+ * Also we do not want to store RxDB-specific metadata in the mongodb database.
+ */
+export declare function rxdbDocToMongo<DocType>(doc: RxDocumentData<DocType>): DocType;

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

@@ -0,0 +1,33 @@
+import { TransactionOptions } from 'mongodb';
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions, WithDeleted } from '../../types';
+import type { MongoDBConnectionString } from '../storage-mongodb/mongodb-types';
+export type MongoDBChangeStreamResumeToken = {
+    _data: string;
+};
+export type MongoDbCheckpointType = {
+    /**
+     * MongoDB has no wait to iterate over events
+     * from the beginning of time.
+     * Therefore we first iterate over the documents by their
+     * _id field and if that reached an end, we iterate from then on
+     * over the changestream resume token.
+     */
+    iterate: 'changestream' | 'docs-by-id';
+    changestreamResumeToken: MongoDBChangeStreamResumeToken;
+    docId?: string;
+};
+export type MongoDBCheckpointIterationState<MongoDocType> = {
+    docs: WithDeleted<MongoDocType>[];
+    checkpoint: MongoDbCheckpointType;
+};
+export type MongoDbConnectionConfig = {
+    connection: MongoDBConnectionString;
+    databaseName: string;
+    collectionName: string;
+    pushTransactionOptions?: TransactionOptions;
+};
+export type SyncOptionsMongoDB<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push' | 'deletedField'> & {
+    mongodb: MongoDbConnectionConfig;
+    pull?: Omit<ReplicationPullOptions<RxDocType, MongoDbCheckpointType>, 'handler' | 'stream$'> & {};
+    push?: Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+};

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

@@ -0,0 +1,16 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { NatsCheckpointType, NatsSyncOptions } from './nats-types.ts';
+export * from './nats-types.ts';
+export * from './nats-helper.ts';
+export declare class RxNatsReplicationState<RxDocType> extends RxReplicationState<RxDocType, NatsCheckpointType> {
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType>;
+    readonly pull?: ReplicationPullOptions<RxDocType, NatsCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(replicationIdentifier: string, collection: RxCollection<RxDocType>, pull?: ReplicationPullOptions<RxDocType, NatsCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateNats<RxDocType>(options: NatsSyncOptions<RxDocType>): RxNatsReplicationState<RxDocType>;

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

@@ -0,0 +1,2 @@
+import type { StoredMsg, Stream } from 'nats';
+export declare function getNatsServerDocumentState(natsStream: Stream, subjectPrefix: string, docId: string): Promise<StoredMsg | undefined>;

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

@@ -0,0 +1,21 @@
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { ConnectionOptions } from 'nats';
+export type NatsCheckpointType = {
+    sequence: number;
+};
+export type NatsSyncPullOptions<RxDocType> = Omit<ReplicationPullOptions<RxDocType, NatsCheckpointType>, 'handler' | 'stream$'> & {};
+export type NatsSyncPushOptions<RxDocType> = Omit<ReplicationPushOptions<RxDocType>, 'handler'> & {};
+export type NatsSyncOptions<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push'> & {
+    connection: ConnectionOptions;
+    streamName: string;
+    /**
+     * NATS subject prefix like 'foo.bar'
+     * which means a message for a document would have the subject
+     * 'foo.bar.myDoc' where the last part 'myDoc' would be the primaryKey in
+     * the RxDB document.
+     * @link https://docs.nats.io/nats-concepts/subjects
+     */
+    subjectPrefix: string;
+    pull?: NatsSyncPullOptions<RxDocType>;
+    push?: NatsSyncPushOptions<RxDocType>;
+};

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

@@ -0,0 +1,5 @@
+import { RxDocumentData, RxJsonSchema, WithDeleted } from '../../types';
+export declare const POSTGRES_INSERT_CONFLICT_CODE = "23505";
+export declare const DEFAULT_MODIFIED_FIELD = "_modified";
+export declare const DEFAULT_DELETED_FIELD = "_deleted";
+export declare function addDocEqualityToQuery<RxDocType>(jsonSchema: RxJsonSchema<RxDocumentData<RxDocType>>, deletedField: string, modifiedField: string, doc: WithDeleted<RxDocType>, query: any): any;

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

@@ -0,0 +1,14 @@
+import { RxReplicationState } from '../replication/index.ts';
+import { SupabaseCheckpoint, SyncOptionsSupabase } from './types.ts';
+import { ReplicationPullOptions, ReplicationPushOptions, RxCollection } from '../../types/index';
+export declare class RxSupabaseReplicationState<RxDocType> extends RxReplicationState<RxDocType, SupabaseCheckpoint> {
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType, any, any, any>;
+    readonly pull?: ReplicationPullOptions<RxDocType, SupabaseCheckpoint> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    constructor(replicationIdentifier: string, collection: RxCollection<RxDocType, any, any, any>, pull?: ReplicationPullOptions<RxDocType, SupabaseCheckpoint> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+}
+export declare function replicateSupabase<RxDocType>(options: SyncOptionsSupabase<RxDocType>): RxSupabaseReplicationState<RxDocType>;

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

@@ -0,0 +1,28 @@
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types';
+import type { SupabaseClient } from '@supabase/supabase-js';
+export type SupabasePullQueryBuilderParams = {
+    query: ReturnType<SupabaseClient['from']>['select'] extends (...args: any[]) => infer R ? R : never;
+    lastPulledCheckpoint: SupabaseCheckpoint | undefined;
+    batchSize: number;
+};
+export type SupabasePullQueryBuilder<RxDocType> = (params: SupabasePullQueryBuilderParams) => SupabasePullQueryBuilderParams['query'] | void;
+export type SyncOptionsSupabase<RxDocType> = Omit<ReplicationOptions<RxDocType, SupabaseCheckpoint>, 'pull' | 'push'> & {
+    client: SupabaseClient;
+    tableName: string;
+    /**
+     * Modified field, default "_modified"
+     */
+    modifiedField?: '_modified' | string;
+    pull?: Omit<ReplicationPullOptions<RxDocType, SupabaseCheckpoint>, 'handler' | 'stream$'> & {
+        /**
+         * Allows modifying the PostgREST query before RxDB fetches remote changes.
+         * You can return a new builder instance or mutate the provided one.
+         */
+        queryBuilder?: SupabasePullQueryBuilder<RxDocType>;
+    };
+    push?: Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+};
+export type SupabaseCheckpoint = {
+    id: string;
+    modified: string;
+};

package/dist/types/plugins/replication-webrtc/connection-handler-simple-peer.d.ts

@@ -0,0 +1,57 @@
+import type { WebRTCConnectionHandlerCreator } from './webrtc-types.ts';
+import type { Instance as SimplePeerInstance, Options as SimplePeerOptions } from 'simple-peer';
+export type SimplePeer = SimplePeerInstance & {
+    id: string;
+};
+export type SimplePeerInitMessage = {
+    type: 'init';
+    yourPeerId: string;
+};
+export type SimplePeerJoinMessage = {
+    type: 'join';
+    room: string;
+};
+export type SimplePeerJoinedMessage = {
+    type: 'joined';
+    otherPeerIds: string[];
+};
+export type SimplePeerSignalMessage = {
+    type: 'signal';
+    room: string;
+    senderPeerId: string;
+    receiverPeerId: string;
+    data: string;
+};
+export type SimplePeerPingMessage = {
+    type: 'ping';
+};
+export type PeerMessage = SimplePeerInitMessage | SimplePeerJoinMessage | SimplePeerJoinedMessage | SimplePeerSignalMessage | SimplePeerPingMessage;
+export declare const DEFAULT_SIGNALING_SERVER: string;
+export type SimplePeerWrtc = SimplePeerOptions['wrtc'];
+export type SimplePeerConfig = SimplePeerOptions['config'];
+export type SimplePeerWebSocketConstructor = {
+    new (url: string): WebSocket;
+};
+export type SimplePeerConnectionHandlerOptions = {
+    /**
+     * If no server is specified, the default signaling server
+     * from signaling.rxdb.info is used.
+     * This server is not reliable and you should use
+     * your own signaling server instead.
+     */
+    signalingServerUrl?: string;
+    wrtc?: SimplePeerWrtc;
+    config?: SimplePeerConfig;
+    webSocketConstructor?: SimplePeerWebSocketConstructor;
+};
+export declare const SIMPLE_PEER_PING_INTERVAL: number;
+/**
+ * Returns a connection handler that uses simple-peer and the signaling server.
+ */
+export declare function getConnectionHandlerSimplePeer({ signalingServerUrl, wrtc, config, webSocketConstructor }: SimplePeerConnectionHandlerOptions): WebRTCConnectionHandlerCreator<SimplePeer>;
+/**
+ * Multiple people had problems because it requires to have
+ * the nextTick() method in the runtime. So we check here and
+ * throw a helpful error.
+ */
+export declare function ensureProcessNextTickIsSet(): void;

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

@@ -0,0 +1,27 @@
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
+import type { RxCollection, RxError, RxReplicationHandler, RxTypeError } from '../../types/index.d.ts';
+import type { WebRTCConnectionHandler, WebRTCPeerState, WebRTCReplicationCheckpoint, RxWebRTCReplicationState, SyncOptionsWebRTC } from './webrtc-types.ts';
+export declare function replicateWebRTC<RxDocType, PeerType>(options: SyncOptionsWebRTC<RxDocType, PeerType>): Promise<RxWebRTCReplicationPool<RxDocType, PeerType>>;
+/**
+ * Because the WebRTC replication runs between many instances,
+ * we use a Pool instead of returning a single replication state.
+ */
+export declare class RxWebRTCReplicationPool<RxDocType, PeerType> {
+    readonly collection: RxCollection<RxDocType, any, any, any>;
+    readonly options: SyncOptionsWebRTC<RxDocType, PeerType>;
+    readonly connectionHandler: WebRTCConnectionHandler<PeerType>;
+    peerStates$: BehaviorSubject<Map<PeerType, WebRTCPeerState<RxDocType, PeerType>>>;
+    canceled: boolean;
+    masterReplicationHandler: RxReplicationHandler<RxDocType, WebRTCReplicationCheckpoint>;
+    subs: Subscription[];
+    error$: Subject<RxError | RxTypeError>;
+    constructor(collection: RxCollection<RxDocType, any, any, any>, options: SyncOptionsWebRTC<RxDocType, PeerType>, connectionHandler: WebRTCConnectionHandler<PeerType>);
+    addPeer(peer: PeerType, replicationState?: RxWebRTCReplicationState<RxDocType>): void;
+    removePeer(peer: PeerType): void;
+    awaitFirstPeer(): Promise<Map<PeerType, WebRTCPeerState<RxDocType, PeerType>>>;
+    cancel(): Promise<void>;
+}
+export * from './webrtc-helper.ts';
+export * from './signaling-server.ts';
+export * from './webrtc-types.ts';
+export * from './connection-handler-simple-peer.ts';

package/dist/types/plugins/replication-webrtc/signaling-server.d.ts

@@ -0,0 +1,17 @@
+import type { WebSocket, ServerOptions } from 'ws';
+export declare const PEER_ID_LENGTH = 12;
+export type ServerPeer = {
+    id: string;
+    socket: WebSocket;
+    rooms: Set<string>;
+    lastPing: number;
+};
+/**
+ * Starts a WebRTC signaling server
+ * that can be used in tests.
+*/
+export declare function startSignalingServerSimplePeer(serverOptions: ServerOptions): Promise<{
+    port: number | undefined;
+    server: import("ws").Server<typeof WebSocket, typeof import("http").IncomingMessage>;
+    localUrl: string;
+}>;

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

@@ -0,0 +1,16 @@
+import type { HashFunction } from '../../types/index.d.ts';
+import type { WebRTCConnectionHandler, WebRTCMessage, WebRTCResponse } from './webrtc-types.ts';
+/**
+ * To deterministically define which peer is master and
+ * which peer is fork, we compare the storage tokens.
+ * But we have to hash them before, to ensure that
+ * a storageToken like 'aaaaaa' is not always the master
+ * for all peers.
+ */
+export declare function isMasterInWebRTCReplication(hashFunction: HashFunction, ownStorageToken: string, otherStorageToken: string): Promise<boolean>;
+/**
+ * Send a message to the peer and await the answer.
+ * @throws with an EmptyErrorImpl if the peer connection
+ * was closed before an answer was received.
+ */
+export declare function sendMessageAndAwaitAnswer<PeerType>(handler: WebRTCConnectionHandler<PeerType>, peer: PeerType, message: WebRTCMessage): Promise<WebRTCResponse>;

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

@@ -0,0 +1,51 @@
+import { Observable, Subscription } from 'rxjs';
+import type { MaybePromise, ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions, RxError, RxReplicationHandler, RxStorageDefaultCheckpoint, RxTypeError, StringKeys } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import { WebsocketMessageResponseType, WebsocketMessageType } from '../replication-websocket/index.ts';
+export type WebRTCReplicationCheckpoint = RxStorageDefaultCheckpoint;
+export type WebRTCMessage = Omit<WebsocketMessageType, 'method' | 'collection'> & {
+    method: StringKeys<RxReplicationHandler<any, any>> | 'token';
+};
+export type WebRTCResponse = Omit<WebsocketMessageResponseType, 'collection'>;
+export type PeerWithMessage<PeerType> = {
+    peer: PeerType;
+    message: WebRTCMessage;
+};
+export type PeerWithResponse<PeerType> = {
+    peer: PeerType;
+    response: WebRTCResponse;
+};
+export type WebRTCConnectionHandler<PeerType> = {
+    connect$: Observable<PeerType>;
+    disconnect$: Observable<PeerType>;
+    message$: Observable<PeerWithMessage<PeerType>>;
+    response$: Observable<PeerWithResponse<PeerType>>;
+    error$: Observable<RxError | RxTypeError>;
+    send(peer: PeerType, message: WebRTCMessage | WebRTCResponse): Promise<void>;
+    close(): Promise<void>;
+};
+export type WebRTCConnectionHandlerCreator<PeerType> = (opts: SyncOptionsWebRTC<any, PeerType>) => Promise<WebRTCConnectionHandler<PeerType>>;
+export type WebRTCSyncPushOptions<RxDocType> = Omit<ReplicationPushOptions<RxDocType>, 'handler'> & {};
+export type WebRTCSyncPullOptions<RxDocType> = Omit<ReplicationPullOptions<RxDocType, WebRTCReplicationCheckpoint>, 'handler' | 'stream$'> & {};
+export type SyncOptionsWebRTC<RxDocType, PeerType> = Omit<ReplicationOptions<RxDocType, WebRTCReplicationCheckpoint>, 'pull' | 'push' | 'replicationIdentifier' | 'deletedField' | 'live' | 'autostart' | 'waitForLeadership'> & {
+    /**
+     * It will only replicate with other instances
+     * that use the same topic.
+     */
+    topic: string;
+    connectionHandlerCreator: WebRTCConnectionHandlerCreator<PeerType>;
+    /**
+     * Run on new peers so that bad peers can be blocked.
+     * If returns true, the peer is valid and it will replicate.
+     * If returns false, it will drop the peer.
+     */
+    isPeerValid?: (peer: PeerType) => MaybePromise<boolean>;
+    pull?: WebRTCSyncPullOptions<RxDocType>;
+    push?: WebRTCSyncPushOptions<RxDocType>;
+};
+export type RxWebRTCReplicationState<RxDocType> = RxReplicationState<RxDocType, WebRTCReplicationCheckpoint>;
+export type WebRTCPeerState<RxDocType, PeerType> = {
+    peer: PeerType;
+    replicationState?: RxWebRTCReplicationState<RxDocType>;
+    subs: Subscription[];
+};

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

@@ -0,0 +1,3 @@
+export * from './websocket-client.ts';
+export * from './websocket-server.ts';
+export * from './websocket-types.ts';

package/dist/types/plugins/replication-websocket/websocket-client.d.ts

@@ -0,0 +1,13 @@
+import { RxReplicationState } from '../replication/index.ts';
+import { WebsocketClientOptions } from './websocket-types.ts';
+import { Subject, BehaviorSubject } from 'rxjs';
+import type { RxError } from '../../types/index.d.ts';
+export type WebsocketClient = {
+    url: string;
+    socket: any;
+    connected$: BehaviorSubject<boolean>;
+    message$: Subject<any>;
+    error$: Subject<RxError>;
+};
+export declare function createWebSocketClient<RxDocType>(options: WebsocketClientOptions<RxDocType>): Promise<WebsocketClient>;
+export declare function replicateWithWebsocketServer<RxDocType, CheckpointType>(options: WebsocketClientOptions<RxDocType>): Promise<RxReplicationState<RxDocType, CheckpointType>>;

package/dist/types/plugins/replication-websocket/websocket-server.d.ts

@@ -0,0 +1,6 @@
+import type { RxDatabase, RxReplicationHandler } from '../../types/index.d.ts';
+import { type ServerOptions } from 'ws';
+import type { WebsocketServerOptions, WebsocketServerState } from './websocket-types.ts';
+export declare function startSocketServer(options: ServerOptions): WebsocketServerState;
+export declare function getReplicationHandlerByCollection<RxDocType>(database: RxDatabase<any>, collectionName: string): RxReplicationHandler<RxDocType, any>;
+export declare function startWebsocketServer(options: WebsocketServerOptions): WebsocketServerState;

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

@@ -0,0 +1,32 @@
+import type { Observable } from 'rxjs';
+import type { ServerOptions, ClientOptions, WebSocketServer, WebSocket } from 'ws';
+import type { RxCollection, RxDatabase, RxReplicationHandler, StringKeys } from '../../types/index.d.ts';
+export type WebsocketServerOptions = {
+    database: RxDatabase<any, any, any>;
+} & ServerOptions;
+export type WebsocketServerState = {
+    server: WebSocketServer;
+    close: () => Promise<void>;
+    onConnection$: Observable<WebSocket>;
+};
+export type WebsocketClientOptions<RxDocType> = {
+    replicationIdentifier: string;
+    collection: RxCollection<RxDocType>;
+    url: string;
+    batchSize?: number;
+    live?: boolean;
+    headers?: {
+        [k: string]: string;
+    };
+} & ClientOptions;
+export type WebsocketMessageType = {
+    id: string;
+    collection: string;
+    method: StringKeys<RxReplicationHandler<any, any>> | 'auth';
+    params: any[];
+};
+export type WebsocketMessageResponseType = {
+    id: string;
+    collection: string;
+    result: any;
+};

package/dist/types/plugins/state/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { DeepReadonly, RxJsonSchema } from '../../types';
+import type { RxStateDocument } from './types';
+export declare const RX_STATE_SCHEMA_TITLE = "RxStateCollection";
+export declare const RX_STATE_ID_LENGTH = 14;
+export declare const RX_STATE_COLLECTION_SCHEMA: DeepReadonly<RxJsonSchema<RxStateDocument>>;
+export declare function nextRxStateId(lastId?: string): string;
+/**
+ * Only non-primitives can be used as a key in WeakMap
+ */
+export declare function isValidWeakMapKey(key: any): boolean;

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

@@ -0,0 +1,4 @@
+import type { RxDatabase, RxPlugin, RxState } from '../../types/index.d.ts';
+export * from './helpers.ts';
+export declare function addState<T>(this: RxDatabase, namespace?: string): Promise<RxState<T>>;
+export declare const RxDBStatePlugin: RxPlugin;

package/dist/types/plugins/state/rx-state.d.ts

@@ -0,0 +1,46 @@
+import { Observable, Subject } from 'rxjs';
+import type { RxCollection, RxDatabase, RxQuery, RxDocument, Paths } from '../../types';
+import { RxStateDocument, RxStateOperation, RxStateModifier } from './types.ts';
+/**
+ * RxDB internally used properties are
+ * prefixed with lodash _ to make them less
+ * likely to clash with actual state properties
+ * from the user.
+ */
+export declare class RxStateBase<T, Reactivity = unknown> {
+    readonly prefix: string;
+    readonly collection: RxCollection<RxStateDocument>;
+    _id: number;
+    _state: T | any;
+    $: Observable<T>;
+    _lastIdQuery: RxQuery<RxStateDocument, RxDocument<RxStateDocument, {}> | null>;
+    _nonPersisted: {
+        path: string;
+        modifier: RxStateModifier;
+    }[];
+    _writeQueue: Promise<void>;
+    _initDone: boolean;
+    _instanceId: string;
+    _ownEmits$: Subject<T>;
+    constructor(prefix: string, collection: RxCollection<RxStateDocument>);
+    set(path: Paths<T> | '', modifier: RxStateModifier): Promise<void>;
+    /**
+     * To have deterministic writes,
+     * and to ensure that multiple js realms do not overwrite
+     * each other, the write happens with incremental ids
+     * that would throw conflict errors and trigger a retry.
+     */
+    _triggerWrite(): Promise<void>;
+    mergeOperationsIntoState(operations: RxStateOperation[]): void;
+    get(path?: Paths<T>): any;
+    get$(path?: Paths<T>): Observable<any>;
+    get$$(path?: Paths<T>): Reactivity;
+    /**
+     * Merges the state operations into a single write row
+     * to store space and make recreating the state from
+     * disc faster.
+     */
+    _cleanup(): Promise<void>;
+}
+export declare function createRxState<T>(database: RxDatabase, prefix: string): Promise<RxStateBase<T>>;
+export declare function mergeOperationsIntoState<T>(state: T, operations: RxStateOperation[]): void;

package/dist/types/plugins/state/types.d.ts

@@ -0,0 +1,28 @@
+import { DeepReadonly } from '../../types';
+/**
+ *
+ */
+export type RxStateDocument = {
+    /**
+     * Ensures that when multiple
+     * javascript realms write at the same time,
+     * we do not overwrite each other but instead
+     * one write must conflict-error and retry.
+     * The clock value is also the primary key.
+     * The clock value contains incremental numbers
+     * in a string format like '0001', '0123'...
+     */
+    id: string;
+    /**
+     * Id of the JavaScript Instance of RxState
+     * that did the write. Used to optimise performance
+     * by not running these modifiers twice.
+     */
+    sId: string;
+    ops: RxStateOperation[];
+};
+export type RxStateOperation = {
+    k: string;
+    v: any;
+};
+export type RxStateModifier = (preValue: DeepReadonly<any>) => any;

package/dist/types/plugins/storage-denokv/denokv-helper.d.ts

@@ -0,0 +1,16 @@
+export declare const RX_STORAGE_NAME_DENOKV = "denokv";
+export declare function getDenoKVIndexName(index: string[]): string;
+/**
+ * Used for non-index rows that contain the document data,
+ * not just a documentId
+ */
+export declare const DENOKV_DOCUMENT_ROOT_PATH = "||";
+export declare const CLEANUP_INDEX: string[];
+/**
+ * Get the global Deno variable from globalThis.Deno
+ * so that compiling with plain typescript does not fail.
+ * Deno has no way to just "download" the deno typings,
+ * so we have to use the "any" type here.
+ */
+export declare function getDenoGlobal(): any;
+export declare function commitWithRetry(buildTx: () => any): Promise<any>;

package/dist/types/plugins/storage-denokv/denokv-query.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedQuery, RxStorageQueryResult } from '../../types/index.d.ts';
+import { RxStorageInstanceDenoKV } from "./rx-storage-instance-denokv.ts";
+export declare function queryDenoKV<RxDocType>(instance: RxStorageInstanceDenoKV<RxDocType>, preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;

package/dist/types/plugins/storage-denokv/denokv-types.d.ts

@@ -0,0 +1,17 @@
+import type { RxDocumentData } from "../../types/index.d.ts";
+export type DenoKVSettings = {
+    consistencyLevel: "strong" | "eventual";
+    openKvPath?: string;
+    batchSize?: number;
+};
+export type DenoKVStorageInternals<RxDocType> = {
+    indexes: {
+        [indexName: string]: DenoKVIndexMeta<RxDocType>;
+    };
+};
+export type DenoKVIndexMeta<RxDocType> = {
+    indexId: string;
+    indexName: string;
+    index: string[];
+    getIndexableString: (doc: RxDocumentData<RxDocType>) => string;
+};

package/dist/types/plugins/storage-denokv/index.d.ts

@@ -0,0 +1,11 @@
+import type { RxStorage, RxStorageInstanceCreationParams } from '../../types/index.d.ts';
+import type { DenoKVSettings, DenoKVStorageInternals } from './denokv-types.ts';
+import { RxStorageInstanceDenoKV } from "./rx-storage-instance-denokv.ts";
+export declare class RxStorageDenoKV implements RxStorage<DenoKVStorageInternals<any>, DenoKVSettings> {
+    settings: DenoKVSettings;
+    name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    constructor(settings: DenoKVSettings);
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, DenoKVSettings>): Promise<RxStorageInstanceDenoKV<RxDocType>>;
+}
+export declare function getRxStorageDenoKV(settings?: DenoKVSettings): RxStorageDenoKV;