@quranjs/api 3.7.0 → 3.9.0

package/README.md

@@ -82,6 +82,82 @@ the same event IDs so downstream processing can identify duplicates.
 
 For browser or mobile apps, use `@quranjs/api/public`. Public usage docs live in the API docs portal.
 
+### App State
+
+App State stores app-owned JSON documents for signed-in users. It is available
+from both runtime entrypoints under `client.auth.v1.appState`. Read the enabled
+data groups before writing, use a fresh high-entropy idempotency key for each
+logical mutation, and store quoted ETags unchanged.
+
+```typescript
+const config = await client.auth.v1.appState.getConfiguration();
+
+const created = await client.auth.v1.appState.putDocument(
+  "settings",
+  "theme",
+  { value: { mode: "dark" }, schemaVersion: 1 },
+  { idempotencyKey: crypto.randomUUID(), ifNoneMatch: "*" },
+);
+
+const current = await client.auth.v1.appState.getDocument("settings", "theme");
+await client.auth.v1.appState.putDocument(
+  "settings",
+  "theme",
+  { value: { mode: "light" }, schemaVersion: 1 },
+  { idempotencyKey: crypto.randomUUID(), ifMatch: current.etag! },
+);
+```
+
+For offline startup, page through `bootstrap()` until `hasMore` is false and
+then persist `nextSyncToken`. Apply each `getChanges()` page and its next token
+atomically. On HTTP 410, preserve pending writes, bootstrap and drain changes,
+replay pending writes, and then pull again. An unchanged replay request retains
+its idempotency key; a conflict rebase rotates it with the changed fingerprint.
+
+For transactional offline reconciliation, provide an account-scoped durable
+`AppStateStore`. Its `transaction(accountId, reducer)` implementation must
+initialize missing accounts, run the reducer synchronously, and atomically
+commit the complete draft only when the reducer returns successfully. Reducers
+must not perform network I/O. The reconciler stages bootstrap pages separately,
+applies change pages with their tokens atomically, replays immutable local
+replacements, and rejects responses from an account that is no longer active.
+
+```typescript
+import { createAppStateReconciler } from "@quranjs/api/public";
+
+const appState = createAppStateReconciler({
+  accountId: signedInAccountId, // Explicit identity; never derive it from a token.
+  store: durableAppStateStore,
+  transport: client.auth.v1.appState,
+});
+
+await appState.putDocument("settings", "theme", {
+  schemaVersion: 1,
+  value: { mode: "dark" },
+});
+await appState.reconcile();
+
+const state = await appState.getState();
+const theme = state.visible["settings/theme"];
+
+await appState.switchAccount(
+  nextSignedInAccountId,
+  nextAccountClient.auth.v1.appState,
+);
+```
+
+Account switching replaces the local account boundary and transport atomically. Create a separate
+client/transport whose immutable session belongs to the target account; do not pass a facade that
+reads a mutable cross-account session at request time. An in-flight request retains the transport
+captured for its original account, and its late result cannot commit after the generation changes.
+
+`putDocument()` and `deleteDocument()` only queue local mutations. Call
+`reconcile()` to pull, replay the captured pending set, and pull again. Calls to
+`reconcile()` are serialized, while local queue writes remain available. On a
+strict `412` conflict, the complete replacement is rebased onto the refreshed
+ETag with a new idempotency key. `createAppStateMemoryStore()` is available for
+tests and short-lived sessions; it is not durable across process restarts.
+
 Existing `QuranClient` imports from `@quranjs/api` remain supported for backwards compatibility:
 
 ```typescript
@@ -135,6 +211,24 @@ Mushaf snapshots include layout metadata, pages, publicly distributable font
 assets, and words. Store the final `nextSyncToken` and use it with the same
 `resources` filter on subsequent sync calls.
 
+Word-by-word transliterations use their resource content ID and expose a typed,
+camel-cased snapshot payload:
+
+```ts
+import type { WordByWordTransliterationSnapshotRecord } from "@quranjs/api";
+
+await client.resources.sync({
+  bootstrap: true,
+  resources: "word_by_word_transliterations:60",
+});
+
+const transliterations =
+  await client.resources.findSnapshot<WordByWordTransliterationSnapshotRecord>(
+    "word_by_word_transliterations",
+    60,
+  );
+```
+
 ## Links
 
 - [Quran Foundation](https://quran.foundation) — Our mission to make the Quran accessible to everyone

package/dist/app-state-state-DN5xrHqP.d.mts

@@ -0,0 +1,528 @@
+type ApiParams = Record<string, string | number | boolean | unknown[] | undefined | Record<string, boolean>>;
+/**
+ * Base parameters that are common across most API endpoints
+ */
+interface BaseApiParams extends ApiParams {
+    /** Language for the response */
+    language?: Language;
+}
+/**
+ * Pagination parameters
+ */
+interface PaginationParams extends ApiParams {
+    /** Page number for pagination */
+    page?: number;
+    /** Number of items per page */
+    perPage?: number;
+}
+type BinaryString = "0" | "1";
+declare enum SearchMode {
+    Advanced = "advanced",
+    Quick = "quick"
+}
+/**
+ * Search parameters
+ */
+interface SearchParams extends BaseApiParams {
+    /** Search mode */
+    mode: SearchMode;
+    /** Search query */
+    query: string;
+    /** Filter translations */
+    filterTranslations?: string | string[];
+    /** For advanced search, limit to exact matches */
+    exactMatchesOnly?: BinaryString;
+    /** Include text in the response */
+    getText?: BinaryString;
+    /** Include highlighted text */
+    highlight?: BinaryString;
+    /** Quick search navigational results count */
+    navigationalResultsNumber?: number;
+    /** Quick search verse results count */
+    versesResultsNumber?: number;
+    /** Comma-separated list of indexes */
+    indexes?: string | string[];
+    /** Page number for pagination */
+    page?: number;
+    /** Number of results to return */
+    size?: number;
+    /** Translation IDs to use for language detection */
+    translationIds?: string | number | Array<string | number>;
+    /** Quran fields to include in verse filters */
+    fields?: Partial<Record<VerseField, boolean>>;
+    /** Translation fields to include in verse filters */
+    translationFields?: Partial<Record<TranslationField, boolean>>;
+    /** Word fields to include in verse filters */
+    wordFields?: Partial<Record<WordField, boolean>>;
+    /** Include word data in verse filters */
+    words?: boolean;
+}
+
+type AppStateJsonValue = boolean | number | string | null | AppStateJsonValue[] | {
+    [key: string]: AppStateJsonValue;
+};
+interface AppStateSuccess<T> {
+    data: T;
+    success: true;
+}
+type AppStateResponse<T> = AppStateSuccess<T> & {
+    /** Opaque quoted ETag. Store and send it unchanged. */
+    etag: string | null;
+    /** HTTP 200 for a read/replacement or 201 for a newly created document. */
+    status: number;
+};
+interface AppStateCollection {
+    maxDocumentsPerUser: number;
+    name: string;
+    requiresPrecondition: boolean;
+}
+interface AppStateLimits {
+    changeRetentionDays: number;
+    maxDocumentBytes: number;
+    maxDocumentsPerUser: number;
+    quotaBytesPerUser: number;
+}
+interface AppStateConfiguration {
+    collections: AppStateCollection[];
+    configVersion: number;
+    limits: AppStateLimits;
+}
+interface AppStateDocument {
+    collection: string;
+    key: string;
+    schemaVersion: number;
+    updatedAt: string;
+    value: AppStateJsonValue;
+    version: number;
+}
+interface AppStateDocumentWithEtag extends AppStateDocument {
+    etag: string;
+}
+interface AppStateMutationResult {
+    collection: string;
+    key: string;
+    schemaVersion: number;
+    updatedAt: string;
+    version: number;
+}
+interface AppStatePage {
+    hasMore: boolean;
+    items: AppStateDocumentWithEtag[];
+    nextCursor: string | null;
+}
+interface AppStateBootstrapPage extends AppStatePage {
+    nextSyncToken: string | null;
+}
+interface AppStateChange extends AppStateDocumentWithEtag {
+    operation: "delete" | "upsert";
+}
+interface AppStateChangesPage {
+    changes: AppStateChange[];
+    hasMore: boolean;
+    nextSyncToken: string;
+}
+interface AppStatePageOptions extends ApiParams {
+    cursor?: string;
+    limit?: number;
+}
+interface AppStateChangesOptions extends ApiParams {
+    limit?: number;
+}
+interface AppStatePutBody {
+    schemaVersion: number;
+    value: AppStateJsonValue;
+}
+type AppStatePrecondition = {
+    ifMatch: string;
+    ifNoneMatch?: never;
+} | {
+    ifMatch?: never;
+    ifNoneMatch: string;
+} | {
+    ifMatch?: never;
+    ifNoneMatch?: never;
+};
+type AppStateMutationOptions = {
+    idempotencyKey: string;
+} & AppStatePrecondition;
+/** Structural low-level transport used by App State reconciliation clients. */
+interface AppStateTransport {
+    bootstrap(options?: AppStatePageOptions): Promise<AppStateSuccess<AppStateBootstrapPage>>;
+    deleteDocument(collection: string, key: string, options: AppStateMutationOptions): Promise<void>;
+    getChanges(since: string, options?: AppStateChangesOptions): Promise<AppStateSuccess<AppStateChangesPage>>;
+    getConfiguration(): Promise<AppStateSuccess<AppStateConfiguration>>;
+    getDocument(collection: string, key: string): Promise<AppStateResponse<AppStateDocument>>;
+    listDocuments(collection: string, options?: AppStatePageOptions): Promise<AppStateSuccess<AppStatePage>>;
+    putDocument(collection: string, key: string, body: AppStatePutBody, options: AppStateMutationOptions): Promise<AppStateResponse<AppStateMutationResult>>;
+}
+type AppStateStoredDocument = AppStateChange;
+interface AppStatePendingMutationBase {
+    collection: string;
+    idempotencyKey: string;
+    ifMatch?: string;
+    ifNoneMatch?: string;
+    key: string;
+    localRevision: number;
+}
+interface AppStatePendingPut extends AppStatePendingMutationBase {
+    body: AppStatePutBody;
+    method: "PUT";
+}
+interface AppStatePendingDelete extends AppStatePendingMutationBase {
+    method: "DELETE";
+}
+type AppStatePendingMutation = AppStatePendingDelete | AppStatePendingPut;
+interface AppStateAccountState {
+    bootstrapCursor: string | null;
+    localRevision: number;
+    pendingMutations: AppStatePendingMutation[];
+    shadow: Record<string, AppStateStoredDocument>;
+    stagingBootstrap: Record<string, AppStateStoredDocument> | null;
+    syncToken: string | null;
+}
+interface AppStateVisibleDocument {
+    collection: string;
+    etag: string | null;
+    key: string;
+    pending: boolean;
+    schemaVersion: number;
+    updatedAt: string | null;
+    value: AppStateJsonValue;
+    version: number | null;
+}
+interface AppStateStateView extends AppStateAccountState {
+    visible: Record<string, AppStateVisibleDocument>;
+}
+type AppStateStoreReducer<T> = (state: AppStateAccountState) => T;
+/**
+ * Account-scoped durable storage for the reconciliation engine. Implementations
+ * must initialize missing accounts and commit a reducer's complete synchronous
+ * state transition atomically. If the reducer throws, no state may be changed.
+ */
+interface AppStateStore {
+    transaction<T>(accountId: string, reducer: AppStateStoreReducer<T>): Promise<T>;
+}
+interface AppStateReconcilerOptions {
+    accountId: string;
+    createIdempotencyKey?: () => string;
+    maxRebaseAttempts?: number;
+    pageSize?: number;
+    store: AppStateStore;
+    transport: AppStateTransport;
+}
+interface AppStateReconciler {
+    deleteDocument(collection: string, key: string): Promise<AppStateStateView>;
+    getState(): Promise<AppStateStateView>;
+    putDocument(collection: string, key: string, body: AppStatePutBody): Promise<AppStateStateView>;
+    reconcile(): Promise<AppStateStateView>;
+    /**
+     * Atomically switch the local account boundary and the transport whose
+     * credentials are bound to that account. The transport must not read a
+     * mutable cross-account session at request time.
+     */
+    switchAccount(accountId: string, transport: AppStateTransport): Promise<AppStateStateView>;
+}
+
+type AuthService = "auth" | "quranReflect";
+
+/**
+ * Custom fetcher function type that matches the native fetch API
+ */
+type CustomFetcher = typeof fetch;
+type RuntimeMode = "server" | "public";
+type HTTPMethod = "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+interface QuranFetchClient {
+    fetch<T = unknown>(url: string, params?: ApiParams): Promise<T>;
+}
+type ApiService = "analytics" | "content" | "search" | AuthService | "oauth2";
+interface ServiceEnvironmentConfig {
+    gatewayUrl?: string;
+    tokenHost?: string;
+    oauth2BaseUrl?: string;
+    analyticsBaseUrl?: string;
+    contentBaseUrl?: string;
+    searchBaseUrl?: string;
+    authBaseUrl?: string;
+    quranReflectBaseUrl?: string;
+}
+interface QuranClientConfig {
+    /** Client ID for authentication */
+    clientId: string;
+    /** Client secret for authentication */
+    clientSecret: string;
+    /** Legacy gateway base URL for content/search APIs */
+    contentBaseUrl?: string;
+    /** Legacy OAuth2 token host URL */
+    authBaseUrl?: string;
+    /** Custom fetch implementation */
+    fetch?: CustomFetcher;
+    /** Default parameters for all API calls */
+    defaults?: Partial<BaseApiParams>;
+}
+interface UserSession {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    scope?: string;
+    tokenType?: string;
+    expiresAt?: number;
+}
+interface TokenStorage {
+    getSession?: () => UserSession | null | undefined | Promise<UserSession | null | undefined>;
+    setSession?: (session: UserSession | null) => void | Promise<void>;
+    clearSession?: () => void | Promise<void>;
+}
+interface BaseRuntimeClientConfig {
+    clientId: string;
+    fetch?: CustomFetcher;
+    defaults?: Partial<BaseApiParams>;
+    services?: ServiceEnvironmentConfig;
+    userSession?: UserSession;
+    storage?: TokenStorage;
+}
+interface ServerClientConfig extends BaseRuntimeClientConfig {
+    clientSecret: string;
+}
+interface PublicClientConfig extends BaseRuntimeClientConfig {
+    clientType: "public" | "confidential-proxy";
+}
+interface CachedToken {
+    value: string;
+    expiresAt: number;
+}
+interface TokenResponse {
+    access_token: string;
+    token_type?: string;
+    expires_in: number;
+    refresh_token?: string;
+    id_token?: string;
+    scope?: string;
+}
+interface OperationRequest {
+    path?: Record<string, string | number>;
+    query?: ApiParams;
+    body?: string | URLSearchParams | Record<string, unknown> | null;
+    headers?: Record<string, string>;
+    method?: HTTPMethod;
+    auth?: "auto" | "none" | "app" | "user";
+    accessToken?: string;
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+    contentType?: string;
+    onResponse?: (metadata: {
+        headers: Headers;
+        status: number;
+    }) => void;
+    preserveResponseKeys?: boolean;
+}
+
+interface QuranReflectPostReference {
+    chapterId: number;
+    from: number;
+    to: number;
+    id?: string;
+}
+interface QuranReflectPostMention {
+    marker: string;
+    userId: string;
+    displayName: string;
+}
+type QuranReflectRoomPostStatus = 0 | 1 | 2;
+interface CreateQuranReflectPostPayload {
+    body: string;
+    draft: boolean;
+    references: QuranReflectPostReference[];
+    mentions: QuranReflectPostMention[];
+    roomId?: number;
+    roomPostStatus?: QuranReflectRoomPostStatus;
+    postAsAuthorId?: string;
+    publishedAt?: string | Date;
+}
+type UpdateQuranReflectPostPayload = Partial<CreateQuranReflectPostPayload>;
+interface QuranReflectPost {
+    id: number | string;
+    authorId?: string;
+    body?: string;
+    commentsCount?: number;
+    createdAt?: string;
+    discussionId?: number;
+    draft?: boolean;
+    estimatedReadingTime?: number;
+    featuredAt?: string;
+    global?: boolean;
+    hidden?: boolean;
+    languageId?: number;
+    languageName?: string;
+    likesCount?: number;
+    mentions?: QuranReflectPostMention[];
+    moderationStatus?: number;
+    postTypeId?: number | null;
+    postTypeName?: string;
+    publishedAt?: string;
+    pushedUpAt?: string;
+    references?: QuranReflectPostReference[];
+    removed?: boolean;
+    reported?: boolean;
+    reviewedAt?: string;
+    roomId?: number | null;
+    roomPostStatus?: number;
+    toxicityScore?: number;
+    updatedAt?: string;
+    verified?: boolean;
+    views?: number;
+    viewsCount?: number;
+}
+interface QuranReflectPostMutationResponse {
+    success: boolean;
+    data?: QuranReflectPost;
+    post?: QuranReflectPost;
+    error?: unknown;
+}
+
+declare enum Language {
+    ARABIC = "ar",
+    ENGLISH = "en",
+    URDU = "ur",
+    BENGALI = "bn",
+    TURKISH = "tr",
+    SPANISH = "es",
+    GERMAN = "de",
+    BOSNIAN = "bs",
+    RUSSIAN = "ru",
+    ALBANIAN_AL = "al",
+    FRENCH = "fr",
+    DUTCH = "nl",
+    TAMIL = "ta",
+    TAJIK = "tg",
+    INDONESIAN = "id",
+    UZBEK = "uz",
+    VIETNAMESE = "vi",
+    CHINESE = "zh",
+    ITALIAN = "it",
+    JAPANESE = "ja",
+    MALAYALAM = "ml",
+    AMHARIC = "am",
+    KAZAKH = "kk",
+    PORTUGUESE = "pt",
+    TAGALOG = "tl",
+    THAI = "th",
+    KOREAN = "ko",
+    HINDI = "hi",
+    KURDISH = "ku",
+    HAUSA = "ha",
+    AZERI = "az",
+    SWAHILI = "sw",
+    PERSIAN = "fa",
+    SERBIAN = "sr",
+    MARANAO = "mrn",
+    AMAZIGH = "zgh",
+    ASSAMESE = "as",
+    BULGARIAN = "bg",
+    CHECHEN = "ce",
+    CZECH = "cs",
+    DIVEHI = "dv",
+    FINNISH = "fi",
+    GUJAARATI = "gu",
+    HEBREW = "he",
+    GEORGIAN = "ka",
+    CENTRAL_KHMER = "km",
+    GANDA = "lg",
+    MARATHI = "mr",
+    YORUBA = "yo",
+    MALAY = "ms",
+    NEPALI = "ne",
+    SWEDISH = "sv",
+    TELUGU = "te",
+    TATAR = "tt",
+    UYGHUR = "ug",
+    UKRAINIAN = "uk",
+    NORWEGIAN = "no",
+    OROMO = "om",
+    POLISH = "pl",
+    PASHTO = "ps",
+    ROMANIAN = "ro",
+    SINDHI = "sd",
+    NORTHERN_SAMI = "se",
+    SINHALA = "si",
+    SOMALI = "so",
+    ALBANIAN_SQ = "sq"
+}
+declare enum QuranFont {
+    MadaniV1 = "code_v1",
+    MadaniV2 = "code_v2",
+    Uthmani = "text_uthmani"
+}
+type VerseField = "chapterId" | "textUthmani" | "textUthmaniSimple" | "textImlaei" | "textImlaeiSimple" | "textIndopak" | "textIndopakNastaleeq" | "textUthmaniTajweed" | "imageUrl" | "imageWidth" | "codeV1" | "codeV2" | "v1Page" | "v2Page";
+type WordField = "v1Page" | "v2Page" | "textUthmani" | "textImlaei" | "textIndopak" | "verseKey" | "location" | "codeV1" | "codeV2";
+type TranslationField = "resourceName" | "verseId" | "languageId" | "languageName" | "verseKey" | "chapterId" | "verseNumber" | "juzNumber" | "hizbNumber" | "rubNumber" | "pageNumber";
+type VerseRecitationField = "id" | "chapterId" | "segments" | "format";
+
+declare const QuranHttpErrorClass: {
+    new (response: Response, payload: unknown): {
+        readonly headers: Headers;
+        readonly payload: unknown;
+        readonly status: number;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    fromResponse(response: Response): Promise<{
+        readonly headers: Headers;
+        readonly payload: unknown;
+        readonly status: number;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    }>;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+type QuranHttpErrorConstructor = typeof QuranHttpErrorClass;
+interface QuranHttpError extends Error {
+    readonly headers: Headers;
+    readonly payload: unknown;
+    readonly status: number;
+}
+declare const QuranHttpError: QuranHttpErrorConstructor;
+
+type AppStateErrorCode = "app_state_data_deleted" | "app_state_disabled" | "app_state_policy_changed" | "app_state_unavailable" | "bootstrap_required" | "collection_not_allowed" | "document_not_found" | "document_too_large" | "idempotency_key_reused" | "internal_server_error" | "insufficient_scope" | "invalid_collection" | "invalid_etag" | "invalid_idempotency_key" | "invalid_json" | "invalid_key" | "invalid_precondition" | "invalid_sync_token" | "invalid_token" | "namespace_resolution_unavailable" | "payload_too_large" | "precondition_failed" | "precondition_required" | "quota_exceeded" | "rate_limit_exceeded" | "sync_token_expired";
+interface AppStateServiceError {
+    code: AppStateErrorCode;
+    details?: {
+        currentETag?: string | null;
+        [key: string]: unknown;
+    };
+    message?: string;
+    [key: string]: unknown;
+}
+interface AppStateErrorPayload {
+    details: {
+        currentETag?: string | null;
+        error: AppStateErrorCode | AppStateServiceError;
+        [key: string]: unknown;
+    };
+    message: string;
+    success: false;
+    type: string;
+}
+type AppStateHttpError = QuranHttpError & {
+    readonly payload: AppStateErrorPayload;
+};
+declare const getAppStateErrorCode: (error: unknown) => AppStateErrorCode | undefined;
+declare function isAppStateHttpError(error: unknown, code?: AppStateErrorCode): error is AppStateHttpError;
+
+declare const createAppStateReconciler: ({ accountId: initialAccountId, createIdempotencyKey, maxRebaseAttempts, pageSize, store, transport: initialTransport, }: AppStateReconcilerOptions) => AppStateReconciler;
+
+type AppStateProtocolErrorCode = "bootstrap_cursor_missing" | "bootstrap_sync_token_missing" | "put_response_etag_missing" | "same_version_conflict";
+declare class AppStateProtocolError extends Error {
+    readonly code: AppStateProtocolErrorCode;
+    constructor(code: AppStateProtocolErrorCode);
+}
+declare const createAppStateMemoryStore: (initialStates?: Readonly<Record<string, AppStateAccountState>>) => AppStateStore;
+
+export { type RuntimeMode as $, type AppStateErrorCode as A, type BaseApiParams as B, type AppStatePageOptions as C, type AppStateChangesOptions as D, type AppStatePutBody as E, type AppStateMutationOptions as F, type AppStateTransport as G, type AppStateStoredDocument as H, type AppStatePendingMutationBase as I, type AppStatePendingPut as J, type AppStatePendingDelete as K, Language as L, type AppStatePendingMutation as M, type AppStateAccountState as N, type AppStateVisibleDocument as O, type PaginationParams as P, type QuranClientConfig as Q, type AppStateStateView as R, SearchMode as S, type TranslationField as T, type AppStateStoreReducer as U, type VerseField as V, type WordField as W, type AppStateStore as X, type AppStateReconcilerOptions as Y, type AppStateReconciler as Z, type CustomFetcher as _, QuranHttpError as a, type HTTPMethod as a0, type QuranFetchClient as a1, type ApiService as a2, type ServiceEnvironmentConfig as a3, type UserSession as a4, type TokenStorage as a5, type ServerClientConfig as a6, type PublicClientConfig as a7, type CachedToken as a8, type TokenResponse as a9, type OperationRequest as aa, type QuranReflectPostReference as ab, type QuranReflectPostMention as ac, type QuranReflectRoomPostStatus as ad, type CreateQuranReflectPostPayload as ae, type UpdateQuranReflectPostPayload as af, type QuranReflectPost as ag, type QuranReflectPostMutationResponse as ah, type AppStateErrorPayload as b, type AppStateHttpError as c, createAppStateReconciler as d, AppStateProtocolError as e, createAppStateMemoryStore as f, getAppStateErrorCode as g, QuranFont as h, isAppStateHttpError as i, type VerseRecitationField as j, type ApiParams as k, type BinaryString as l, type SearchParams as m, type AppStateJsonValue as n, type AppStateSuccess as o, type AppStateResponse as p, type AppStateCollection as q, type AppStateLimits as r, type AppStateConfiguration as s, type AppStateDocument as t, type AppStateDocumentWithEtag as u, type AppStateMutationResult as v, type AppStatePage as w, type AppStateBootstrapPage as x, type AppStateChange as y, type AppStateChangesPage as z };