@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/index.d.ts

@@ -0,0 +1,597 @@
+import Reactor from './Reactor.js';
+import { tx, txInit, lookup, getOps, type TxChunk, type TransactionChunk } from './instatx.js';
+import weakHash from './utils/weakHash.js';
+import id from './utils/id.ts';
+import IndexedDBStorage from './IndexedDBStorage.ts';
+import { coerceToDate } from './utils/dates.js';
+import WindowNetworkListener from './WindowNetworkListener.js';
+import { i } from './schema.js';
+import version from './version.ts';
+import { validateQuery, QueryValidationError } from './queryValidation.ts';
+import { validateTransactions, TransactionValidationError } from './transactionValidation.ts';
+import { setInstantWarningsEnabled } from './warningToggle.ts';
+import { StoreInterface, type StoreInterfaceClass, type StoreInterfaceStoreName } from './utils/PersistedObject.ts';
+import { createInstantRouteHandler } from './createRouteHandler.ts';
+import type { InstantRouteHandlerPayloadByType, InstantRouteHandlerType, InstantRouteHandlerBody } from './routeHandlerProtocol.ts';
+import { parseSchemaFromJSON } from './parseSchemaFromJSON.ts';
+import type { Logger } from './utils/log.ts';
+import type { PresenceOpts, PresenceResponse, PresenceSlice, RoomSchemaShape } from './presence.ts';
+import type { DevtoolConfig, IDatabase, IInstantDatabase } from './coreTypes.ts';
+import type { Query, QueryResponse, InstaQLResponse, PageInfoResponse, Exactly, InstantObject, InstaQLParams, InstaQLOptions, InstaQLQueryParams, InstaQLEntity, InstaQLEntitySubquery, InstaQLResult, InstaQLFields, ValidQuery, Cursor, Order, InstaQLQueryEntityResult } from './queryTypes.ts';
+import type { PresencePeer } from './presenceTypes.ts';
+import type { AuthState, User, AuthResult, ConnectionStatus, AppStatusState } from './clientTypes.ts';
+import type { InstantQuery, InstantQueryResult, InstantSchema, InstantEntity, InstantSchemaDatabase } from './helperTypes.ts';
+import type { InstantDBAttr, InstantDBAttrOnDelete, InstantDBCheckedDataType, InstantDBIdent, InstantDBInferredType } from './attrTypes.ts';
+import type { AttrsDefs, CardinalityKind, DataAttrDef, EntitiesDef, EntitiesWithLinks, EntityDef, RoomsDef, InstantSchemaDef, InstantGraph, LinkAttrDef, LinkDef, LinksDef, PresenceOf, ResolveAttrs, RoomsOf, TopicsOf, TopicOf, ValueTypes, InstantUnknownSchema, InstantUnknownSchemaDef, BackwardsCompatibleSchema, UpdateParams, LinkParams, CreateParams, RuleParams } from './schemaTypes.ts';
+import type { InstantRules } from './rulesTypes.ts';
+import type { UploadFileResponse, DeleteFileResponse } from './StorageAPI.ts';
+import { FrameworkClient, type FrameworkConfig } from './framework.ts';
+import type { CheckMagicCodeParams, CheckMagicCodeResponse, ExchangeCodeForTokenParams, SendMagicCodeParams, SendMagicCodeResponse, SignInAsGuestParams, SignInWithIdTokenParams, VerifyMagicCodeParams, VerifyResponse } from './authAPI.ts';
+import { InstantAPIError, type InstantIssue } from './utils/fetch.js';
+import { InstantError } from './InstantError.ts';
+import { SSEConnection, EventSourceType, type EventSourceConstructor } from './Connection.ts';
+import { CallbackEventType as SyncTableCallbackEventType } from './SyncTable.ts';
+import type { SyncTableCallback, CallbackEvent as SyncTableCallbackEvent, InitialSyncBatch as SyncTableInitialSyncBatch, InitialSyncComplete as SyncTableInitialSyncComplete, SyncTransaction as SyncTableSyncTransaction, LoadFromStorage as SyncTableLoadFromStorage, SetupError as SyncTableSetupError } from './SyncTable.ts';
+import { InstantStream, InstantWritableStream, InstantReadableStream, ReadableStreamCtor, WritableStreamCtor } from './Stream.ts';
+import { type InfiniteQueryCallbackResponse, type InfiniteQuerySubscription, getInfiniteQueryInitialSnapshot } from './infiniteQuery.ts';
+type ExactlyOne<T> = {
+    [K in keyof T]: Pick<T, K> & Partial<Record<Exclude<keyof T, K>, never>>;
+}[keyof T];
+export type Config = {
+    appId: string;
+    websocketURI?: string;
+    apiURI?: string;
+    devtool?: boolean | DevtoolConfig;
+    verbose?: boolean;
+    logger?: Logger;
+    queryCacheLimit?: number;
+    useDateObjects: boolean;
+    disableValidation?: boolean;
+};
+export type InstantConfig<S extends InstantSchemaDef<any, any, any>, UseDates extends boolean = false> = {
+    appId: string;
+    schema?: S;
+    websocketURI?: string;
+    firstPartyPath?: string;
+    apiURI?: string;
+    devtool?: boolean | DevtoolConfig;
+    verbose?: boolean;
+    logger?: Logger;
+    queryCacheLimit?: number;
+    useDateObjects: UseDates;
+    disableValidation?: boolean;
+    Store?: StoreInterfaceClass;
+    WritableStream?: WritableStreamCtor;
+    ReadableStream?: ReadableStreamCtor;
+};
+export type ConfigWithSchema<S extends InstantGraph<any, any>> = Config & {
+    schema: S;
+};
+export type TransactionResult = {
+    status: 'synced' | 'enqueued';
+    clientId: string;
+};
+export type PublishTopic<TopicsByKey> = <Key extends keyof TopicsByKey>(topic: Key, data: TopicsByKey[Key]) => void;
+export type SubscribeTopic<PresenceShape, TopicsByKey> = <Key extends keyof TopicsByKey>(topic: Key, onEvent: (event: TopicsByKey[Key], peer: PresenceShape) => void) => () => void;
+export type GetPresence<PresenceShape> = <Keys extends keyof PresenceShape>(opts: PresenceOpts<PresenceShape, Keys>) => PresenceResponse<PresenceShape, Keys> | null;
+export type SubscribePresence<PresenceShape> = <Keys extends keyof PresenceShape>(opts: PresenceOpts<PresenceShape, Keys>, onChange: (slice: PresenceResponse<PresenceShape, Keys>) => void) => () => void;
+export type RoomHandle<PresenceShape, TopicsByKey> = {
+    leaveRoom: () => void;
+    publishTopic: PublishTopic<TopicsByKey>;
+    subscribeTopic: SubscribeTopic<PresenceShape, TopicsByKey>;
+    publishPresence: (data: Partial<PresenceShape>) => void;
+    getPresence: GetPresence<PresenceShape>;
+    subscribePresence: SubscribePresence<PresenceShape>;
+};
+type AuthToken = string;
+type SubscriptionState<Q, Schema, WithCardinalityInference extends boolean> = {
+    error: {
+        message: string;
+        traceId?: string;
+    };
+    data: undefined;
+    pageInfo: undefined;
+} | {
+    error: undefined;
+    data: QueryResponse<Q, Schema, WithCardinalityInference>;
+    pageInfo: PageInfoResponse<Q>;
+};
+type InstaQLSubscriptionState<Schema, Q, UseDates extends boolean> = {
+    error: {
+        message: string;
+        traceId?: string;
+    };
+    data: undefined;
+    pageInfo: undefined;
+} | {
+    error: undefined;
+    data: InstaQLResponse<Schema, Q, UseDates>;
+    pageInfo: PageInfoResponse<Q>;
+};
+type LifecycleSubscriptionState<Q, Schema, WithCardinalityInference extends boolean> = SubscriptionState<Q, Schema, WithCardinalityInference> & {
+    isLoading: boolean;
+};
+type InstaQLLifecycleState<Schema, Q, UseDates extends boolean = false> = (InstaQLSubscriptionState<Schema, Q, UseDates> & {
+    isLoading: boolean;
+}) | {
+    isLoading: true;
+    data: undefined;
+    pageInfo: undefined;
+    error: undefined;
+};
+type UnsubscribeFn = () => void;
+type SignoutOpts = {
+    invalidateToken?: boolean;
+};
+/**
+ * Functions to log users in and out.
+ *
+ * @see https://instantdb.com/docs/auth
+ */
+declare class Auth {
+    private db;
+    constructor(db: Reactor);
+    /**
+     * Sends a magic code to the user's email address.
+     *
+     * Once you send the magic code, see {@link auth.signInWithMagicCode} to let the
+     * user verify.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *  db.auth.sendMagicCode({email: "example@gmail.com"})
+     *    .catch((err) => console.error(err.body?.message))
+     */
+    sendMagicCode: (params: SendMagicCodeParams) => Promise<SendMagicCodeResponse>;
+    /**
+     * Verify a magic code that was sent to the user's email address.
+     *
+     * @see https://instantdb.com/docs/auth
+     *
+     * @example
+     *  db.auth.signInWithMagicCode({email: "example@gmail.com", code: "123456"})
+     *       .catch((err) => console.error(err.body?.message))
+     */
+    signInWithMagicCode: (params: CheckMagicCodeParams) => Promise<CheckMagicCodeResponse>;
+    /**
+     * Sign in a user with a refresh token
+     *
+     * @see https://instantdb.com/docs/backend#frontend-auth-sign-in-with-token
+     *
+     * @example
+     *   // Get the token from your backend
+     *   const token = await fetch('/signin', ...);
+     *   //Sign in
+     *   db.auth.signInWithToken(token);
+     */
+    signInWithToken: (token: AuthToken) => Promise<VerifyResponse>;
+    /**
+     * Sign in as guest, creating a new user without email
+     *
+     * @see https://instantdb.com/docs/auth
+     *
+     * @example
+     *   db.auth.signInAsGuest();
+     */
+    signInAsGuest: (params?: SignInAsGuestParams) => Promise<VerifyResponse>;
+    /**
+     * Create an authorization url to sign in with an external provider.
+     *
+     * @see https://instantdb.com/docs/auth
+     *
+     * @example
+     *   // Get the authorization url from your backend
+     *   const url = db.auth.createAuthorizationUrl({
+     *     clientName: "google",
+     *     redirectURL: window.location.href,
+     *   });
+     *
+     *   // Put it in a sign in link
+     *   <a href={url}>Log in with Google</a>
+     */
+    createAuthorizationURL: (params: {
+        clientName: string;
+        redirectURL: string;
+        extraFields?: Record<string, any>;
+    }) => string;
+    /**
+     * Sign in with the id_token from an external provider like Google
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   db.auth
+     *  .signInWithIdToken({
+     *    // Token from external service
+     *    idToken: id_token,
+     *    // The name you gave the client when you registered it with Instant
+     *    clientName: "google",
+     *    // The nonce, if any, that you used when you initiated the auth flow
+     *    // with the external service.
+     *    nonce: your_nonce
+     *  })
+     *  .catch((err) => console.error(err.body?.message));
+     *
+     */
+    signInWithIdToken: (params: SignInWithIdTokenParams) => Promise<CheckMagicCodeResponse>;
+    /**
+     * Sign in with the id_token from an external provider like Google
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   db.auth
+     *  .exchangeOAuthCode({
+     *    // code received in redirect from OAuth callback
+     *    code: code
+     *    // The PKCE code_verifier, if any, that you used when you
+     *    // initiated the auth flow
+     *    codeVerifier: your_code_verifier
+     *  })
+     *  .catch((err) => console.error(err.body?.message));
+     *
+     */
+    exchangeOAuthCode: (params: ExchangeCodeForTokenParams) => Promise<CheckMagicCodeResponse>;
+    /**
+     * OpenID Discovery path for use with tools like
+     * expo-auth-session that use auto-discovery of
+     * OAuth parameters.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   const discovery = useAutoDiscovery(
+     *     db.auth.issuerURI()
+     *   );
+     */
+    issuerURI: () => string;
+    /**
+     * Sign out the current user
+     */
+    signOut: (opts?: SignoutOpts) => Promise<void>;
+}
+type FileOpts = {
+    contentType?: string;
+    contentDisposition?: string;
+    fileSize?: number;
+};
+/**
+ * Functions to manage file storage.
+ */
+declare class Storage {
+    private db;
+    constructor(db: Reactor);
+    /**
+     * Uploads file at the provided path.
+     *
+     * @see https://instantdb.com/docs/storage
+     * @example
+     *   const [file] = e.target.files; // result of file input
+     *   const data = await db.storage.uploadFile('photos/demo.png', file);
+     */
+    uploadFile: (path: string, file: File | Blob, opts?: FileOpts) => Promise<UploadFileResponse>;
+    /**
+     * Deletes a file by path name.
+     *
+     * @deprecated Use `db.transact` to delete files instead:
+     * @example
+     *   // Delete by id
+     *   db.transact(db.tx.$files[fileId].delete());
+     *
+     *   // Delete by path
+     *   db.transact(db.tx.$files[lookup('path', 'photos/demo.png')].delete());
+     *
+     *   // Delete multiple files
+     *   db.transact(fileIds.map(id => db.tx.$files[id].delete()));
+     *
+     * @see https://instantdb.com/docs/storage
+     */
+    delete: (pathname: string) => Promise<DeleteFileResponse>;
+    /**
+     * @deprecated. Use `db.storage.uploadFile` instead
+     * remove in the future.
+     */
+    upload: (pathname: string, file: File) => Promise<boolean>;
+    /**
+     * @deprecated Use `db.storage.uploadFile` instead
+     */
+    put: (pathname: string, file: File) => Promise<boolean>;
+    /**
+     * @deprecated. getDownloadUrl will be removed in the future.
+     * Use `useQuery` instead to query and fetch for valid urls
+     *
+     * db.useQuery({
+     *   $files: {
+     *     $: {
+     *       where: {
+     *         path: "moop.png"
+     *       }
+     *     }
+     *   }
+     * })
+     */
+    getDownloadUrl: (pathname: string) => Promise<any>;
+}
+type CreateReadStreamOpts = {
+    clientId?: string | null | undefined;
+    streamId?: string | null | undefined;
+    byteOffset?: number | null | undefined;
+    ruleParams?: RuleParams | null | undefined;
+};
+type CreateWriteStreamOpts = {
+    clientId: string;
+    /**
+     * A function that takes a promise and ensures that the current program stays alive
+     * until the promise is resolved.
+     *
+     * Useful in serverless environments to ensure the writer fully flushes before the
+     * environment is shut down.
+     *
+     * @example
+     * import { after } from 'next/server'
+     * db.streams.createWriteStream({clientId, waitUntil: after})
+     */
+    waitUntil?: (promise: Promise<any>) => void | null | undefined;
+    ruleParams?: RuleParams | null | undefined;
+};
+/**
+ * Functions to manage streams.
+ */
+declare class Streams {
+    private db;
+    constructor(db: Reactor);
+    /**
+     * Creates a new ReadableStream for the given clientId.
+     *
+     * @example
+     *   const stream = db.streams.createReadStream({clientId: clientId})
+     *   for await (const chunk of stream) {
+     *     console.log(chunk);
+     *   }
+     */
+    createReadStream: (opts: CreateReadStreamOpts) => InstantReadableStream<string>;
+    /**
+     * Creates a new WritableStream for the given clientId.
+     *
+     * @example
+     *   const writeStream = db.streams.createWriteStream({clientId: clientId})
+     *   const writer = writeStream.getWriter();
+     *   writer.write('Hello world');
+     *   writer.close();
+     */
+    createWriteStream: (opts: CreateWriteStreamOpts) => InstantWritableStream<string>;
+}
+declare function coerceQuery(o: any): any;
+declare class InstantCoreDatabase<Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean = false> implements IInstantDatabase<Schema> {
+    _reactor: Reactor<RoomsOf<Schema>>;
+    auth: Auth;
+    storage: Storage;
+    streams: Streams;
+    tx: TxChunk<Schema>;
+    constructor(reactor: Reactor<RoomsOf<Schema>>);
+    /**
+     * Use this to write data! You can create, update, delete, and link objects
+     *
+     * @see https://instantdb.com/docs/instaml
+     *
+     * @example
+     *   // Create a new object in the `goals` namespace
+     *   const goalId = id();
+     *   db.transact(db.tx.goals[goalId].update({title: "Get fit"}))
+     *
+     *   // Update the title
+     *   db.transact(db.tx.goals[goalId].update({title: "Get super fit"}))
+     *
+     *   // Delete it
+     *   db.transact(db.tx.goals[goalId].delete())
+     *
+     *   // Or create an association:
+     *   todoId = id();
+     *   db.transact([
+     *    db.tx.todos[todoId].update({ title: 'Go on a run' }),
+     *    db.tx.goals[goalId].link({todos: todoId}),
+     *  ])
+     */
+    transact(chunks: TransactionChunk<any, any> | TransactionChunk<any, any>[]): Promise<TransactionResult>;
+    getLocalId(name: string): Promise<string>;
+    /**
+     * Use this to query your data!
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *  // listen to all goals
+     *  db.subscribeQuery({ goals: {} }, (resp) => {
+     *    console.log(resp.data.goals)
+     *  })
+     *
+     *  // goals where the title is "Get Fit"
+     *  db.subscribeQuery(
+     *    { goals: { $: { where: { title: "Get Fit" } } } },
+     *    (resp) => {
+     *      console.log(resp.data.goals)
+     *    }
+     *  )
+     *
+     *  // all goals, _alongside_ their todos
+     *  db.subscribeQuery({ goals: { todos: {} } }, (resp) => {
+     *    console.log(resp.data.goals)
+     *  });
+     */
+    subscribeQuery<Q extends ValidQuery<Q, Schema>, UseDatesLocal extends boolean = UseDates>(query: Q, cb: (resp: InstaQLSubscriptionState<Schema, Q, UseDatesLocal>) => void, opts?: InstaQLOptions): () => void;
+    /**
+     * Subscribe to a query and incrementally load more items
+     *
+     * Only one top level namespace in the query is allowed.
+     * @example
+     * const { unsubscribe, loadNextPage } = db.subscribeInfiniteQuery({
+     *   posts: {
+     *     $: {
+     *       limit: 20,   // Load 20 posts at a time
+     *       order: {
+     *         createdAt: 'desc',
+     *       },
+     *     },
+     *   },
+     *   (resp) => {
+     *     console.log(resp.data.posts);
+     *   }
+     * });
+     */
+    subscribeInfiniteQuery<Q extends ValidQuery<Q, Schema>>(query: Q, cb: (resp: InfiniteQueryCallbackResponse<Schema, Q, UseDates>) => void, opts?: InstaQLOptions): InfiniteQuerySubscription;
+    /**
+     * Listen for the logged in state. This is useful
+     * for deciding when to show a login screen.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   const unsub = db.subscribeAuth((auth) => {
+     *     if (auth.user) {
+     *     console.log('logged in as', auth.user.email)
+     *    } else {
+     *      console.log('logged out')
+     *    }
+     *  })
+     */
+    subscribeAuth(cb: (auth: AuthResult) => void): UnsubscribeFn;
+    /**
+     * One time query for the logged in state. This is useful
+     * for scenarios where you want to know the current auth
+     * state without subscribing to changes.
+     *
+     * @see https://instantdb.com/docs/auth
+     * @example
+     *   const user = await db.getAuth();
+     *   console.log('logged in as', user.email)
+     */
+    getAuth(): Promise<User | null>;
+    /**
+     * Listen for connection status changes to Instant. This is useful
+     * for building things like connectivity indicators
+     *
+     * @see https://www.instantdb.com/docs/patterns#connection-status
+     * @example
+     *   const unsub = db.subscribeConnectionStatus((status) => {
+     *     const connectionState =
+     *       status === 'connecting' || status === 'opened'
+     *         ? 'authenticating'
+     *       : status === 'authenticated'
+     *         ? 'connected'
+     *       : status === 'closed'
+     *         ? 'closed'
+     *       : status === 'errored'
+     *         ? 'errored'
+     *       : 'unexpected state';
+     *
+     *     console.log('Connection status:', connectionState);
+     *   });
+     */
+    subscribeConnectionStatus(cb: (status: ConnectionStatus) => void): UnsubscribeFn;
+    /**
+     * Observe the app's maintenance-mode state. While read-only, reads and
+     * live queries keep working but writes are rejected. The callback fires
+     * immediately with the current state and again on every change.
+     *
+     * @example
+     *   const unsub = db.subscribeAppStatus(({ isLoading, isReadOnly }) => {
+     *     if (isLoading) return;
+     *     if (isReadOnly) showMaintenanceBanner();
+     *   });
+     */
+    subscribeAppStatus(cb: (state: AppStatusState) => void): UnsubscribeFn;
+    /**
+     * Join a room to publish and subscribe to topics and presence.
+     *
+     * @see https://instantdb.com/docs/presence-and-topics
+     * @example
+     * // init
+     * const db = init();
+     * const room = db.joinRoom(roomType, roomId);
+     * // usage
+     * const unsubscribeTopic = room.subscribeTopic("foo", console.log);
+     * const unsubscribePresence = room.subscribePresence({}, console.log);
+     * room.publishTopic("hello", { message: "hello world!" });
+     * room.publishPresence({ name: "joe" });
+     * // later
+     * unsubscribePresence();
+     * unsubscribeTopic();
+     * room.leaveRoom();
+     */
+    joinRoom<RoomType extends string & keyof RoomsOf<Schema>>(roomType?: RoomType, roomId?: string, opts?: {
+        initialPresence?: Partial<PresenceOf<Schema, RoomType>>;
+    }): RoomHandle<PresenceOf<Schema, RoomType>, TopicsOf<Schema, RoomType>>;
+    shutdown(): void;
+    /**
+     * Use this for one-off queries.
+     * Returns local data if available, otherwise fetches from the server.
+     * Because we want to avoid stale data, this method will throw an error
+     * if the user is offline or there is no active connection to the server.
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *
+     *  const resp = await db.queryOnce({ goals: {} });
+     *  console.log(resp.data.goals)
+     */
+    queryOnce<Q extends ValidQuery<Q, Schema>>(query: Q, opts?: InstaQLOptions): Promise<{
+        data: InstaQLResponse<Schema, Q, UseDates>;
+        pageInfo: PageInfoResponse<Q>;
+    }>;
+    /**
+     * @deprecated This is an experimental function that is not yet ready for production use.
+     * Use this function to sync an entire namespace.
+     * It has many limitations that will be removed in the future:
+     * 1. Must be used with an admin token
+     * 2. Does not support permissions
+     * 3. Does not support where clauses
+     * 4. Does not support links
+     * It also does not support multiple top-level namespaces. For example,
+     *  {posts: {}, users: {}} is invalid. Only `posts` or `users` is allowed, but not both.
+     */
+    _syncTableExperimental<Q extends ValidQuery<Q, Schema>>(query: ExactlyOne<Q>, cb: SyncTableCallback<Schema, Q, UseDates>): (opts?: {
+        keepSubscription: boolean | null | undefined;
+    } | null | undefined) => void;
+}
+/**
+ *
+ * The first step: init your application!
+ *
+ * Visit https://instantdb.com/dash to get your `appId` :)
+ *
+ * @example
+ *  import { init } from "@instantdb/core"
+ *
+ *  const db = init({ appId: "my-app-id" })
+ *
+ *  // You can also provide a schema for type safety and editor autocomplete!
+ *
+ *  import { init } from "@instantdb/core"
+ *  import schema from ""../instant.schema.ts";
+ *
+ *  const db = init({ appId: "my-app-id", schema })
+ *
+ *  // To learn more: https://instantdb.com/docs/modeling-data
+ */
+declare function init<Schema extends InstantSchemaDef<any, any, any> = InstantUnknownSchema, UseDates extends boolean = false>(config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+    useDateObjects?: UseDates;
+}, Store?: any, NetworkListener?: any, versions?: {
+    [key: string]: string;
+}, EventSourceImpl?: any): InstantCoreDatabase<Schema, UseDates>;
+/**
+ * @deprecated
+ * `init_experimental` is deprecated. You can replace it with `init`.
+ *
+ * @example
+ *
+ * // Before
+ * import { init_experimental } from "@instantdb/core"
+ * const db = init_experimental({  ...  });
+ *
+ * // After
+ * import { init } from "@instantdb/core"
+ * const db = init({ ...  });
+ */
+declare const init_experimental: typeof init;
+export { init, init_experimental, id, tx, txInit, lookup, validateQuery, QueryValidationError, validateTransactions, parseSchemaFromJSON, TransactionValidationError, FrameworkClient, Reactor, InstantAPIError, setInstantWarningsEnabled, i, getOps, coerceQuery, weakHash, coerceToDate, IndexedDBStorage, WindowNetworkListener, InstantCoreDatabase, Auth, Storage, Streams, version, InstantError, getInfiniteQueryInitialSnapshot, SyncTableCallbackEventType, type IDatabase, type RoomSchemaShape, type Query, type QueryResponse, type InstaQLResponse, type PageInfoResponse, type InstantObject, type Exactly, type TransactionChunk, type AuthState, type ConnectionStatus, type AppStatusState, type User, type AuthToken, type TxChunk, type SubscriptionState, type InstaQLSubscriptionState, type LifecycleSubscriptionState, type InstaQLLifecycleState, type PresenceOpts, type PresenceSlice, type PresenceResponse, type PresencePeer, type InstaQLParams, type ValidQuery, type Cursor, type InstaQLOptions, type InstaQLQueryParams, type InstantQuery, type InstantQueryResult, type InstantSchema, type InstantEntity, type InstantSchemaDatabase, type InstaQLFields, type Order, type InstaQLQueryEntityResult, type InfiniteQueryCallbackResponse, type InfiniteQuerySubscription, type AttrsDefs, type CardinalityKind, type DataAttrDef, type EntitiesDef, type InstantUnknownSchemaDef, type EntitiesWithLinks, type EntityDef, type RoomsDef, type InstantGraph, type LinkAttrDef, type LinkDef, type LinksDef, type ResolveAttrs, type ValueTypes, type RoomsOf, type PresenceOf, type TopicsOf, type TopicOf, type InstaQLEntity, type InstaQLResult, type InstaQLEntitySubquery, type InstantSchemaDef, type InstantUnknownSchema, type IInstantDatabase, type BackwardsCompatibleSchema, type InstantRules, type UpdateParams, type LinkParams, type CreateParams, type RuleParams, type InstantDBAttr, type InstantDBAttrOnDelete, type InstantDBCheckedDataType, type InstantDBIdent, type InstantDBInferredType, type CheckMagicCodeParams, type CheckMagicCodeResponse, type ExchangeCodeForTokenParams, type SendMagicCodeParams, type SendMagicCodeResponse, type SignInAsGuestParams, type SignInWithIdTokenParams, type VerifyMagicCodeParams, type VerifyResponse, type FileOpts, type UploadFileResponse, type DeleteFileResponse, SSEConnection, type EventSourceType, type FrameworkConfig, type EventSourceConstructor, InstantStream, type WritableStreamCtor, type ReadableStreamCtor, type CreateReadStreamOpts, type CreateWriteStreamOpts, type InstantWritableStream, type InstantReadableStream, type SyncTableCallback, type SyncTableCallbackEvent, type SyncTableInitialSyncBatch, type SyncTableInitialSyncComplete, type SyncTableSyncTransaction, type SyncTableLoadFromStorage, type SyncTableSetupError, type InstantIssue, StoreInterface, type StoreInterfaceClass, type StoreInterfaceStoreName, createInstantRouteHandler, type InstantRouteHandlerPayloadByType, type InstantRouteHandlerType, type InstantRouteHandlerBody, type Logger, };
+/** @deprecated Use StoreInterface instead */
+export declare const StorageInterface: typeof StoreInterface;
+/** @deprecated Use StoreInterfaceStoreName instead */
+export type StorageInterfaceStoreName = StoreInterfaceStoreName;