Navigate

API reference

@pyric/cli/register/client/firestore

106 published symbols from @pyric/cli

Generated from the TypeScript declarations shipped at this import path.

Variables

addDoc

const addDoc: typeof addDoc;

and

const and: typeof and;

arrayRemove

const arrayRemove: typeof arrayRemove;

arrayUnion

const arrayUnion: typeof arrayUnion;

Bytes

const Bytes: typeof Bytes;

CACHE_SIZE_UNLIMITED

const CACHE_SIZE_UNLIMITED: -1 = -1;

firebase’s sentinel value, re-exported for settings parity.


collection

const collection: typeof collection;

collectionGroup

const collectionGroup: typeof collectionGroup;

deleteAllPersistentCacheIndexes

const deleteAllPersistentCacheIndexes: UnsupportedServedApi;

deleteDoc

const deleteDoc: typeof deleteDoc;

deleteField

const deleteField: typeof deleteField;

disablePersistentCacheIndexAutoCreation

const disablePersistentCacheIndexAutoCreation: UnsupportedServedApi;

doc

const doc: typeof doc;

documentSnapshotFromJSON

const documentSnapshotFromJSON: UnsupportedServedApi;

enablePersistentCacheIndexAutoCreation

const enablePersistentCacheIndexAutoCreation: UnsupportedServedApi;

endAt

const endAt: typeof endAt;

endBefore

const endBefore: typeof endBefore;

ensureFirestoreConfigured

const ensureFirestoreConfigured: UnsupportedServedApi;

executeWrite

const executeWrite: UnsupportedServedApi;

GeoPoint

const GeoPoint: typeof GeoPoint;

getAggregateFromServer

const getAggregateFromServer: typeof getAggregateFromServer;

getCountFromServer

const getCountFromServer: typeof getCountFromServer;

getDoc

const getDoc: typeof getDoc;

getDocFromCache

const getDocFromCache: typeof getDoc;

getDocFromServer

const getDocFromServer: typeof getDoc;

getDocs

const getDocs: typeof getDocs;

getDocsFromCache

const getDocsFromCache: typeof getDocs;

getDocsFromServer

const getDocsFromServer: typeof getDocs;

getFirestore

const getFirestore: typeof getFirestore;

getPersistentCacheIndexManager

const getPersistentCacheIndexManager: UnsupportedServedApi;

increment

const increment: typeof increment;

limit

const limit: typeof limit;

limitToLast

const limitToLast: typeof limitToLast;

loadBundle

const loadBundle: UnsupportedServedApi;

maximum

const maximum: UnsupportedServedApi;

memoryEagerGarbageCollector

const memoryEagerGarbageCollector: typeof memoryEagerGarbageCollector;

memoryLruGarbageCollector

const memoryLruGarbageCollector: typeof memoryLruGarbageCollector;

minimum

const minimum: UnsupportedServedApi;

namedQuery

const namedQuery: UnsupportedServedApi;

onSnapshot

const onSnapshot: typeof onSnapshot;

onSnapshotResume

const onSnapshotResume: UnsupportedServedApi;

or

const or: typeof or;

orderBy

const orderBy: typeof orderBy;

query

const query: typeof query;

queryEqual

const queryEqual: UnsupportedServedApi;

querySnapshotFromJSON

const querySnapshotFromJSON: UnsupportedServedApi;

refEqual

const refEqual: typeof refEqual;

runTransaction

const runTransaction: typeof runTransaction;

serverTimestamp

const serverTimestamp: typeof serverTimestamp;

setDoc

const setDoc: typeof setDoc;

setIndexConfiguration

const setIndexConfiguration: UnsupportedServedApi;

setLogLevel

const setLogLevel: typeof setLogLevel;

snapshotEqual

const snapshotEqual: UnsupportedServedApi;

startAfter

const startAfter: typeof startAfter;

startAt

const startAt: typeof startAt;

Timestamp

const Timestamp: typeof Timestamp;

updateDoc

const updateDoc: typeof updateDoc;

vector

const vector: typeof vector;

VectorValue

const VectorValue: typeof VectorValue;

where

const where: typeof where;

writeBatch

const writeBatch: typeof writeBatch;

Functions

clearIndexedDbPersistence()

function clearIndexedDbPersistence(_db?: unknown): Promise<void>;

Parameters

ParameterType
_db?unknown

Returns

Promise<void>


connectFirestoreEmulator()

function connectFirestoreEmulator(..._args: unknown[]): void;

The served sandbox already provides the local backend.

Parameters

ParameterType
…_argsunknown[]

Returns

void


disableNetwork()

function disableNetwork(_db?: unknown): Promise<void>;

Parameters

ParameterType
_db?unknown

Returns

Promise<void>


enableIndexedDbPersistence()

function enableIndexedDbPersistence(_db?: unknown): Promise<void>;

Parameters

ParameterType
_db?unknown

Returns

Promise<void>


enableMultiTabIndexedDbPersistence()

function enableMultiTabIndexedDbPersistence(_db?: unknown): Promise<void>;

No-op success, same rationale as enableIndexedDbPersistence — the SharedWorker path already IS the one store every tab reads/writes, so there’s no separate multi-tab mode to opt into over the worker; the in-page fallback has no multi-tab story to begin with.

Parameters

ParameterType
_db?unknown

Returns

Promise<void>


enableNetwork()

function enableNetwork(_db?: unknown): Promise<void>;

Parameters

ParameterType
_db?unknown

Returns

Promise<void>


initializeFirestore()

function initializeFirestore(app?:
  | FirebaseApp
  | Sandbox
  | SandboxContext, settings?: unknown): Firestore;

Parameters

ParameterType
app?| FirebaseApp | Sandbox | SandboxContext
settings?unknown

Returns

Firestore


memoryLocalCache()

function memoryLocalCache(_settings?: unknown): {
  kind: string;
};

Parameters

ParameterType
_settings?unknown

Returns

{
  kind: string;
}
kind
kind: string;

onSnapshotsInSync()

function onSnapshotsInSync(db: unknown, observerOrCallback:
  | () => void
  | {
  next?: () => void;
}): () => void;

Local no-op reimplementation rather than delegating to ip.onSnapshotsInSync: on the worker path db is a ClientDb, not a pyric/firestore Firestore handle, so it doesn’t carry the TARGET_SYMBOL brand ip.onSnapshotsInSync dispatches on. Fires the callback once the current microtask queue settles — same honest approximation as the in-page implementation — on both paths.

Parameters

ParameterType
dbunknown
observerOrCallback| () => void | { next?: () => void; }

Returns

(): void;
Returns

void


persistentLocalCache()

function persistentLocalCache(_settings?: unknown): {
  kind: string;
};

Parameters

ParameterType
_settings?unknown

Returns

{
  kind: string;
}
kind
kind: string;

persistentMultipleTabManager()

function persistentMultipleTabManager(): {
  kind: string;
};

Returns

{
  kind: string;
}
kind
kind: string;

persistentSingleTabManager()

function persistentSingleTabManager(_settings?: unknown): {
  kind: string;
};

Parameters

ParameterType
_settings?unknown

Returns

{
  kind: string;
}
kind
kind: string;

terminate()

function terminate(db?: unknown): Promise<void>;

In-page fallback: forwards to pyric/firestore’s terminate, which genuinely tears the sandbox down via Sandbox.dispose().

Worker path: accepted no-op. The SharedWorker-hosted sandbox is shared across every tab on the page’s origin — disposing it here would tear down listener registries out from under other open tabs, which the real terminate() contract (single-instance teardown) never implies. Documented divergence: over the worker, terminate settles without tearing anything down.

Parameters

ParameterType
db?unknown

Returns

Promise<void>


waitForPendingWrites()

function waitForPendingWrites(_db?: unknown): Promise<void>;

Resolves immediately — sandbox writes apply synchronously in-page; over the worker the RPC ack already settled (judgment zone 4, recorded).

Parameters

ParameterType
_db?unknown

Returns

Promise<void>

References

AbstractUserDataWriter

Re-exports AbstractUserDataWriter


AggregateField

Re-exports AggregateField


aggregateFieldEqual

Re-exports aggregateFieldEqual


AggregateQuerySnapshot

Re-exports AggregateQuerySnapshot


aggregateQuerySnapshotEqual

Re-exports aggregateQuerySnapshotEqual


average

Re-exports average


CollectionReference

Re-exports CollectionReference


count

Re-exports count


documentId

Re-exports documentId


DocumentReference

Re-exports DocumentReference


DocumentSnapshot

Re-exports DocumentSnapshot


FieldPath

Re-exports FieldPath


FieldValue

Re-exports FieldValue


Firestore

Re-exports Firestore


FirestoreError

Re-exports FirestoreError


LoadBundleTask

Re-exports LoadBundleTask


PersistentCacheIndexManager

Re-exports PersistentCacheIndexManager


Query

Re-exports Query


QueryCompositeFilterConstraint

Re-exports QueryCompositeFilterConstraint


QueryConstraint

Re-exports QueryConstraint


QueryDocumentSnapshot

Re-exports QueryDocumentSnapshot


QueryEndAtConstraint

Re-exports QueryEndAtConstraint


QueryFieldFilterConstraint

Re-exports QueryFieldFilterConstraint


QueryLimitConstraint

Re-exports QueryLimitConstraint


QueryOrderByConstraint

Re-exports QueryOrderByConstraint


QuerySnapshot

Re-exports QuerySnapshot


QueryStartAtConstraint

Re-exports QueryStartAtConstraint


SnapshotMetadata

Re-exports SnapshotMetadata


sum

Re-exports sum


Transaction

Re-exports Transaction


WriteBatch

Re-exports WriteBatch