Interface StartLocalFirstGraphOptions

interface StartLocalFirstGraphOptions {
    key?: string;
    onlineSource?: {
        getIsOnline: () => boolean;
        subscribe: (listener: (online: boolean) => void) => () => void;
    };
    persistDebounceMs?: number;
    replayPendingActions?: boolean;
    retryPolicy?: ReplayRetryPolicy;
    storage: GraphPersistenceAdapter;
    store?: Omit<
        Omit<StoreApi<GraphState>, "subscribe"> & {
            subscribe: {
                (
                    listener: (
                        selectedState: GraphState,
                        previousSelectedState: GraphState,
                    ) => void,
                ): () => void;
                <U>(
                    selector: (state: GraphState) => U,
                    listener: (selectedState: U, previousSelectedState: U) => void,
                    options?: {
                        equalityFn?: (a: U, b: U) => boolean;
                        fireImmediately?: boolean;
                    },
                ): () => void;
            };
        },
        "setState",
    > & {
        setState(
            nextStateOrUpdater:
                | GraphState
                | Partial<GraphState>
                | (
                    (
                        state: {
                            appendListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<
                                        ListState,
                                        "ids"
                                        | "isFetching"
                                        | "isFetchingMore"
                                        | "error"
                                        | "stale",
                                    >,
                                >,
                            ) => void;
                            clearEntitySyncMetadata: (type: string, id: string) => void;
                            clearPatch: (type: string, id: string) => void;
                            entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            entityStates: {
                                [x: string]: {
                                    error: string | null;
                                    isFetching: boolean;
                                    lastFetched: number | null;
                                    stale: boolean;
                                };
                            };
                            ingestFetchedList: (
                                type: string,
                                entries: { data: Record<string, unknown>; id: string }[],
                                options?: IngestFetchedListOptions,
                            ) => void;
                            insertIdInList: (
                                key: string,
                                id: string,
                                position: number | "end" | "start",
                            ) => void;
                            invalidateEntity: (type: string, id?: string) => void;
                            invalidateLists: (
                                matcher: string | ((key: string) => boolean),
                            ) => void;
                            invalidateType: (type: string) => void;
                            lists: {
                                [x: string]: {
                                    currentPage: number | null;
                                    error: string | null;
                                    hasNextPage: boolean;
                                    hasPrevPage: boolean;
                                    ids: string[];
                                    isFetching: boolean;
                                    isFetchingMore: boolean;
                                    lastError:
                                        | {
                                            cause?: unknown;
                                            kind: "terminal";
                                            message: string;
                                            name: string;
                                            stack?: (...)
                                            | (...);
                                            status?: (...) | (...);
                                        }
                                        | {
                                            cause?: unknown;
                                            kind: "transient";
                                            message: string;
                                            name: string;
                                            stack?: (...)
                                            | (...);
                                            status?: (...) | (...);
                                        }
                                        | null;
                                    lastFetched: number
                                    | null;
                                    nextCursor: string | null;
                                    pageSize: number | null;
                                    prevCursor: string | null;
                                    stale: boolean;
                                    total: number | null;
                                };
                            };
                            patchEntity: (
                                type: string,
                                id: string,
                                patch: Record<string, unknown>,
                            ) => void;
                            patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            prependListResult: (
                                key: string,
                                ids: string[],
                                meta?: Partial<ListState>,
                            ) => void;
                            readEntity: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => T | null;
                            readEntitySnapshot: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => EntitySnapshot<T & Record<(...), (...)>> | null;
                            removeEntity: (type: string, id: string) => void;
                            removeIdFromAllLists: (type: string, id: string) => void;
                            replaceEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                            setEntityError: (
                                type: string,
                                id: string,
                                error: string | null,
                            ) => void;
                            setEntityFetched: (type: string, id: string) => void;
                            setEntityFetching: (
                                type: string,
                                id: string,
                                fetching: boolean,
                            ) => void;
                            setEntityStale: (type: string, id: string, stale: boolean) => void;
                            setEntitySyncMetadata: (
                                type: string,
                                id: string,
                                metadata: Partial<EntitySyncMetadata>,
                            ) => void;
                            setListError: (
                                key: string,
                                error: string | null,
                                typed?: EntityError | null,
                            ) => void;
                            setListFetching: (key: string, fetching: boolean) => void;
                            setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                            setListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<
                                        ListState,
                                        "ids"
                                        | "isFetching"
                                        | "isFetchingMore"
                                        | "error"
                                        | "stale",
                                    >,
                                >,
                            ) => void;
                            setListStale: (key: string, stale: boolean) => void;
                            syncMetadata: {
                                [x: string]: {
                                    origin: SyncOrigin;
                                    synced: boolean;
                                    updatedAt: number | null;
                                };
                            };
                            unpatchEntity: (type: string, id: string, keys: string[]) => void;
                            upsertEntities: (
                                type: string,
                                entries: { data: Record<string, unknown>; id: string }[],
                            ) => void;
                            upsertEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                        },
                    ) => void
                ),
            shouldReplace?: false,
        ): void;
        setState(
            nextStateOrUpdater:
                | GraphState
                | (
                    (
                        state: {
                            appendListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<
                                        ListState,
                                        "ids"
                                        | "isFetching"
                                        | "isFetchingMore"
                                        | "error"
                                        | "stale",
                                    >,
                                >,
                            ) => void;
                            clearEntitySyncMetadata: (type: string, id: string) => void;
                            clearPatch: (type: string, id: string) => void;
                            entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            entityStates: {
                                [x: string]: {
                                    error: string | null;
                                    isFetching: boolean;
                                    lastFetched: number | null;
                                    stale: boolean;
                                };
                            };
                            ingestFetchedList: (
                                type: string,
                                entries: { data: Record<string, unknown>; id: string }[],
                                options?: IngestFetchedListOptions,
                            ) => void;
                            insertIdInList: (
                                key: string,
                                id: string,
                                position: number | "end" | "start",
                            ) => void;
                            invalidateEntity: (type: string, id?: string) => void;
                            invalidateLists: (
                                matcher: string | ((key: string) => boolean),
                            ) => void;
                            invalidateType: (type: string) => void;
                            lists: {
                                [x: string]: {
                                    currentPage: number | null;
                                    error: string | null;
                                    hasNextPage: boolean;
                                    hasPrevPage: boolean;
                                    ids: string[];
                                    isFetching: boolean;
                                    isFetchingMore: boolean;
                                    lastError:
                                        | {
                                            cause?: unknown;
                                            kind: "terminal";
                                            message: string;
                                            name: string;
                                            stack?: (...)
                                            | (...);
                                            status?: (...) | (...);
                                        }
                                        | {
                                            cause?: unknown;
                                            kind: "transient";
                                            message: string;
                                            name: string;
                                            stack?: (...)
                                            | (...);
                                            status?: (...) | (...);
                                        }
                                        | null;
                                    lastFetched: number
                                    | null;
                                    nextCursor: string | null;
                                    pageSize: number | null;
                                    prevCursor: string | null;
                                    stale: boolean;
                                    total: number | null;
                                };
                            };
                            patchEntity: (
                                type: string,
                                id: string,
                                patch: Record<string, unknown>,
                            ) => void;
                            patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            prependListResult: (
                                key: string,
                                ids: string[],
                                meta?: Partial<ListState>,
                            ) => void;
                            readEntity: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => T | null;
                            readEntitySnapshot: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => EntitySnapshot<T & Record<(...), (...)>> | null;
                            removeEntity: (type: string, id: string) => void;
                            removeIdFromAllLists: (type: string, id: string) => void;
                            replaceEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                            setEntityError: (
                                type: string,
                                id: string,
                                error: string | null,
                            ) => void;
                            setEntityFetched: (type: string, id: string) => void;
                            setEntityFetching: (
                                type: string,
                                id: string,
                                fetching: boolean,
                            ) => void;
                            setEntityStale: (type: string, id: string, stale: boolean) => void;
                            setEntitySyncMetadata: (
                                type: string,
                                id: string,
                                metadata: Partial<EntitySyncMetadata>,
                            ) => void;
                            setListError: (
                                key: string,
                                error: string | null,
                                typed?: EntityError | null,
                            ) => void;
                            setListFetching: (key: string, fetching: boolean) => void;
                            setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                            setListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<
                                        ListState,
                                        "ids"
                                        | "isFetching"
                                        | "isFetchingMore"
                                        | "error"
                                        | "stale",
                                    >,
                                >,
                            ) => void;
                            setListStale: (key: string, stale: boolean) => void;
                            syncMetadata: {
                                [x: string]: {
                                    origin: SyncOrigin;
                                    synced: boolean;
                                    updatedAt: number | null;
                                };
                            };
                            unpatchEntity: (type: string, id: string, keys: string[]) => void;
                            upsertEntities: (
                                type: string,
                                entries: { data: Record<string, unknown>; id: string }[],
                            ) => void;
                            upsertEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                        },
                    ) => void
                ),
            shouldReplace: true,
        ): void;
    };
}