form-snapshots 1.0.6

package/README.md

@@ -0,0 +1,226 @@
+## form-snapshots
+
+For a more complete, multi-page guide, see the **docs mini‑wiki** under `docs/`:
+
+- [Documentation index](./docs/index.md)
+
+**form-snapshots** is a small React library that adds **autosave + history snapshots** to your forms using **IndexedDB (Dexie)** under the hood.
+
+It automatically stores form state while the user is typing, lets them resume unfinished forms, inspect past submissions, and debug failures, all without changing your backend.
+
+### What this project is
+
+- **React hooks and components** for:
+  - **Autosaving** form state to the browser on blur.
+  - **Restoring** the most recent snapshot back into the form.
+  - **Listing** previous sessions and their metadata (status code, error message, timestamps).
+  - **Devtools UI** to inspect and filter form sessions in development.
+- **Storage layer** built on Dexie, so everything lives in the user’s browser (no server required).
+
+### What it is for
+
+- **Long or complex forms** where users might navigate away or lose their work.
+- **Clinical / enterprise / back-office apps** where losing form data is painful and audit/history is important.
+- **Debugging submission problems** (you can see exactly what the user had filled + status codes / errors).
+
+---
+
+## Installation
+
+```bash
+npm install form-snapshots
+# peer deps
+npm install react react-dom dexie dexie-react-hooks react-hook-form
+```
+
+Requires **React 18+**.
+
+---
+
+## Core concepts
+
+- **Session**: one editing “lifetime” of a form (from first visit until successful submit).
+- **Snapshot**: a JSON representation of the form values at a point in time.
+- **Storage**: by default, snapshots are stored in IndexedDB via Dexie.
+
+You identify each form by a **`formName`** string; all hooks and tools use this key to group sessions.
+
+---
+
+## Basic usage: `useFormSnapshots`
+
+`useFormSnapshots` adds autosave and restore to a standard DOM form.
+
+```tsx
+import { useFormSnapshots } from "form-snapshots"
+
+export function ContactForm() {
+  const {
+    formRef,
+    handleBlur,
+    wrapSubmit,
+    restoreLatest,
+    isSubmitted,
+  } = useFormSnapshots("contact-form")
+
+  const onSubmit = wrapSubmit(() => {
+    // Perform your usual submit logic (fetch / mutation / etc.)
+  })
+
+  return (
+    <form ref={formRef} onBlur={handleBlur} onSubmit={onSubmit}>
+      <input name="fullName" placeholder="Full name" />
+      <input name="email" type="email" placeholder="Email" />
+      <textarea name="message" placeholder="Message" />
+
+      <button type="submit">Send</button>
+
+      <button
+        type="button"
+        onClick={restoreLatest}
+        disabled={isSubmitted}
+      >
+        Restore last draft
+      </button>
+    </form>
+  )
+}
+```
+
+**How it works:**
+
+- On blur, the hook reads values from the DOM and saves them to IndexedDB.
+- On mount, it restores the latest snapshot (if any) back into the form.
+- On submit, it closes the session and marks it as `submitted` so new edits start a fresh session.
+
+### Options
+
+```ts
+useFormSnapshots("contact-form", {
+  snapshotsLimit: 24 * 60 * 60 * 1000, // ms to retain history (default: 24h)
+  excludeFields: ["password", "patient.ssn"], // paths to omit from snapshots
+  getValues: () => snapshot,       // custom snapshot source (for controlled forms)
+  applyValues: (snapshot) => {},   // custom restore logic (for controlled forms)
+  discardOnSubmit: true,           // delete session + clear form after submit
+})
+```
+
+Use `getValues` / `applyValues` when your form state lives in React state or is nested/structured, instead of plain DOM inputs.
+
+---
+
+## Global config: `FormSnapshotsProvider`
+
+You can configure defaults once at the application root.
+
+```tsx
+import { FormSnapshotsProvider } from "form-snapshots"
+
+function App() {
+  return (
+    <FormSnapshotsProvider
+      value={{
+        defaultSnapshotsLimit: 7 * 24 * 60 * 60 * 1000, // keep 7 days
+        excludeFields: ["password", "patient.address"],
+        discardOnSubmit: false, // global default, can be overridden per form
+      }}
+    >
+      {/* your routes/components */}
+    </FormSnapshotsProvider>
+  )
+}
+```
+
+Per-form options passed to `useFormSnapshots` are merged with this global config.
+
+---
+
+## Devtools: `FormSnapshotsDevtools`
+
+`FormSnapshotsDevtools` renders a small toggle button and a side panel that shows:
+
+- All form sessions stored locally.
+- Filters by **form name**, **submitted only**, and **errors only**.
+- Timestamps, relative age, status codes, and error messages.
+- Inline table view of the snapshot data for each session.
+- Ability to delete a single session or clear all sessions from local history (dev-only).
+
+It automatically hides itself in production (`import.meta.env.PROD`).
+
+```tsx
+import { FormSnapshotsDevtools } from "form-snapshots"
+
+export function RootLayout() {
+  return (
+    <>
+      {/* your app UI */}
+      <FormSnapshotsDevtools />
+    </>
+  )
+}
+```
+
+---
+
+## Listing history: `useFormSnapshotsList`
+
+`useFormSnapshotsList` lets you build your own history UI for a given form.
+
+```tsx
+import { useFormSnapshotsList } from "form-snapshots"
+
+export function RecentSubmissions() {
+  const { items, isLoading } = useFormSnapshotsList("contact-form", {
+    onlySubmitted: true,
+    onlySuccessful: true,
+    maxAgeMs: 24 * 60 * 60 * 1000, // last 24h
+    limit: 20,
+  })
+
+  if (isLoading) return <p>Loading…</p>
+  if (!items.length) return <p>No recent submissions.</p>
+
+  return (
+    <ul>
+      {items.map((item) => (
+        <li key={item.id}>
+          #{item.id} – {new Date(item.updatedAt).toLocaleString()} – status{" "}
+          {item.statusCode ?? "n/a"}
+        </li>
+      ))}
+    </ul>
+  )
+}
+```
+
+---
+
+## Adapters and advanced usage
+
+The library also exports:
+
+- `useRHFFormSnapshots` – an adapter for **react-hook-form**.
+- `useObjectFormSnapshots` – for generic object/React-state based forms.
+- `FormSnapshotTable` – a table component for rendering snapshot key/value data.
+- `FormSnapshotsClient` and `FormSnapshotsStorage` interfaces – if you want to plug in a custom storage backend instead of Dexie.
+
+These build on the same concepts as `useFormSnapshots` but integrate more tightly with specific form/state libraries.
+
+---
+
+## Building
+
+This package is built with **tsup** and TypeScript:
+
+```bash
+npm run build
+```
+
+The build outputs ESM, CJS, and `.d.ts` type declarations under `dist/`.
+
+---
+
+## License
+
+ISC
+

package/dist/index.d.mts

@@ -0,0 +1,235 @@
+import * as react from 'react';
+import { SyntheticEvent, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { UseFormReturn } from 'react-hook-form';
+import { Dexie, EntityTable } from 'dexie';
+
+type FormSnapshot = Record<string, unknown>;
+interface FormSessionBase {
+    id: number;
+    formName: string;
+    data: string;
+    createdAt: number;
+    updatedAt: number;
+    submitted: boolean;
+    statusCode?: number | null;
+    errorMessage?: string | null;
+}
+interface FormSnapshotsStorage {
+    findActiveSession(formName: string): Promise<FormSessionBase | null>;
+    createSession(formName: string, snapshot: FormSnapshot): Promise<FormSessionBase>;
+    updateSession(id: number, patch: Partial<Pick<FormSessionBase, "data" | "updatedAt" | "submitted" | "statusCode" | "errorMessage">>): Promise<void>;
+    getLatestSession(formName: string): Promise<FormSessionBase | null>;
+    listSessions(formName: string): Promise<FormSessionBase[]>;
+    pruneOlderThan(cutoffMs: number): Promise<void>;
+    /**
+     * Optional hook for storage backends that support deleting a session
+     * entirely. When implemented, it is used by features that discard
+     * submitted sessions instead of keeping them in history.
+     */
+    deleteSession?(id: number): Promise<void>;
+}
+
+interface FormSnapshotsOptions {
+    /** How long in ms to retain history entries. Default: 24 h */
+    snapshotsLimit?: number;
+    /**
+     * Field paths (path/prefix) to exclude while saving snapshots.
+     * E.g. "password", "patient.address".
+     * Merged with the global excludeFields config.
+     */
+    excludeFields?: string[];
+    /**
+     * Override how the current form state is read.
+     *
+     * Use this for controlled forms or nested / structured data models
+     * (e.g. HL7 FHIR Address, HumanName, ContactPoint[]) where values live
+     * in React state rather than plain DOM elements.
+     */
+    getValues?: () => FormSnapshot;
+    /**
+     * Override how a saved snapshot is applied back to the form.
+     *
+     * Receives the full snapshot that was previously returned by `getValues`.
+     */
+    applyValues?: (snapshot: FormSnapshot) => void;
+    /**
+     * When true, the active session is deleted from storage and the form
+     * is cleared immediately after submit so that submitted data is not
+     * kept in history. Can be overridden globally via provider config.
+     */
+    discardOnSubmit?: boolean;
+}
+declare function useFormSnapshots(formName: string, options?: FormSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: SyntheticEvent<HTMLFormElement>) => void) => (e: SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+
+interface useFormSnapshotsListOptions {
+    /**
+     * Whether to return only submitted (completed) sessions.
+     * Default: false (both submitted and in-progress).
+     */
+    onlySubmitted?: boolean;
+    /**
+     * Whether to return only successful (2xx) submission results.
+     * Default: false (all statusCode values).
+     */
+    onlySuccessful?: boolean;
+    /**
+     * Maximum age in ms. E.g. last 24 hours = 24 * 60 * 60 * 1000.
+     * Default: unlimited.
+     */
+    maxAgeMs?: number;
+    /**
+     * Maximum number of records to return.
+     * Default: unlimited.
+     */
+    limit?: number;
+}
+interface FormHistoryListItem {
+    id: number;
+    formName: string;
+    createdAt: number;
+    updatedAt: number;
+    submitted: boolean;
+    statusCode: number | null;
+    errorMessage: string | null;
+    /**
+     * Age in ms relative to \"now\".
+     */
+    ageMs: number;
+}
+declare function useFormSnapshotsList(formName: string, options?: useFormSnapshotsListOptions): {
+    items: FormHistoryListItem[];
+    isLoading: boolean;
+};
+
+interface FormSnapshotsGlobalConfig {
+    defaultSnapshotsLimit?: number;
+    /**
+     * Field paths (path/prefix) to exclude while saving snapshots.
+     * E.g. ["password", "patient.address"]
+     */
+    excludeFields?: string[];
+    /**
+     * When true, submitted sessions are discarded and the form is cleared
+     * immediately after submit instead of keeping the data in history.
+     * Can be overridden per form via hook options.
+     */
+    discardOnSubmit?: boolean;
+}
+interface FormSnapshotsProviderProps {
+    value?: FormSnapshotsGlobalConfig;
+    children: ReactNode;
+}
+declare function FormSnapshotsProvider({ value, children, }: Readonly<FormSnapshotsProviderProps>): react_jsx_runtime.JSX.Element;
+declare function useFormSnapshotsConfig(): FormSnapshotsGlobalConfig;
+
+declare function FormSnapshotsDevtools(): react_jsx_runtime.JSX.Element | null;
+
+interface FormSnapshotTableProps {
+    /**
+     * JSON-stringified snapshot. Genellikle `FormSession.data`.
+     */
+    data: string;
+    /**
+     * Message to display when the table is empty.
+     * Default: "No data captured yet."
+     */
+    emptyMessage?: string;
+    /**
+     * Extra class names for the outer wrapper.
+     */
+    className?: string;
+}
+declare function FormSnapshotTable({ data, emptyMessage, className, }: Readonly<FormSnapshotTableProps>): react_jsx_runtime.JSX.Element;
+
+type WithoutSnapshotOverrides = Omit<FormSnapshotsOptions, "getValues" | "applyValues">;
+interface RHFSnapshotsOptions extends WithoutSnapshotOverrides {
+}
+declare function useRHFFormSnapshots<TFieldValues extends Record<string, unknown>>(formName: string, form: UseFormReturn<TFieldValues>, options?: RHFSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => void) => (e: react.SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+interface ObjectStateSnapshotsOptions extends WithoutSnapshotOverrides {
+}
+declare function useObjectFormSnapshots<TState extends Record<string, unknown>>(formName: string, state: TState, setState: (next: TState) => void, options?: ObjectStateSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => void) => (e: react.SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+
+declare class FormSnapshotsClient {
+    private readonly storage;
+    private readonly formName;
+    private readonly snapshotsLimit;
+    constructor(params: {
+        storage: FormSnapshotsStorage;
+        formName: string;
+        snapshotsLimit: number;
+    });
+    initSession(): Promise<FormSessionBase>;
+    saveSnapshot(sessionId: number, snapshot: FormSnapshot): Promise<void>;
+    markSubmitted(sessionId: number): Promise<void>;
+    deleteSession(sessionId: number): Promise<void>;
+    setSubmissionResult(params: {
+        sessionId: number;
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }): Promise<void>;
+    getLatestSnapshot(): Promise<FormSnapshot | null>;
+    openNewSessionFromSnapshot(snapshot: FormSnapshot): Promise<FormSessionBase>;
+}
+
+interface FormSession {
+    id: number;
+    formName: string;
+    /** JSON-serialised record of field name → value */
+    data: string;
+    createdAt: number;
+    updatedAt: number;
+    /** true = the form was submitted; session is closed / read-only */
+    submitted: boolean;
+    /** Optional HTTP-like status code for the last submit attempt */
+    statusCode?: number | null;
+    /** Optional error message when the last submit attempt failed */
+    errorMessage?: string | null;
+}
+declare const db: Dexie & {
+    formSessions: EntityTable<FormSession, "id">;
+};
+
+export { type FormHistoryListItem, type FormSession, type FormSessionBase, type FormSnapshot, FormSnapshotTable, type FormSnapshotTableProps, FormSnapshotsClient, FormSnapshotsDevtools, type FormSnapshotsOptions, FormSnapshotsProvider, type FormSnapshotsProviderProps, type FormSnapshotsStorage, type ObjectStateSnapshotsOptions, type RHFSnapshotsOptions, db, useFormSnapshots, useFormSnapshotsConfig, useFormSnapshotsList, type useFormSnapshotsListOptions, useObjectFormSnapshots, useRHFFormSnapshots };

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import * as react from 'react';
+import { SyntheticEvent, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { UseFormReturn } from 'react-hook-form';
+import { Dexie, EntityTable } from 'dexie';
+
+type FormSnapshot = Record<string, unknown>;
+interface FormSessionBase {
+    id: number;
+    formName: string;
+    data: string;
+    createdAt: number;
+    updatedAt: number;
+    submitted: boolean;
+    statusCode?: number | null;
+    errorMessage?: string | null;
+}
+interface FormSnapshotsStorage {
+    findActiveSession(formName: string): Promise<FormSessionBase | null>;
+    createSession(formName: string, snapshot: FormSnapshot): Promise<FormSessionBase>;
+    updateSession(id: number, patch: Partial<Pick<FormSessionBase, "data" | "updatedAt" | "submitted" | "statusCode" | "errorMessage">>): Promise<void>;
+    getLatestSession(formName: string): Promise<FormSessionBase | null>;
+    listSessions(formName: string): Promise<FormSessionBase[]>;
+    pruneOlderThan(cutoffMs: number): Promise<void>;
+    /**
+     * Optional hook for storage backends that support deleting a session
+     * entirely. When implemented, it is used by features that discard
+     * submitted sessions instead of keeping them in history.
+     */
+    deleteSession?(id: number): Promise<void>;
+}
+
+interface FormSnapshotsOptions {
+    /** How long in ms to retain history entries. Default: 24 h */
+    snapshotsLimit?: number;
+    /**
+     * Field paths (path/prefix) to exclude while saving snapshots.
+     * E.g. "password", "patient.address".
+     * Merged with the global excludeFields config.
+     */
+    excludeFields?: string[];
+    /**
+     * Override how the current form state is read.
+     *
+     * Use this for controlled forms or nested / structured data models
+     * (e.g. HL7 FHIR Address, HumanName, ContactPoint[]) where values live
+     * in React state rather than plain DOM elements.
+     */
+    getValues?: () => FormSnapshot;
+    /**
+     * Override how a saved snapshot is applied back to the form.
+     *
+     * Receives the full snapshot that was previously returned by `getValues`.
+     */
+    applyValues?: (snapshot: FormSnapshot) => void;
+    /**
+     * When true, the active session is deleted from storage and the form
+     * is cleared immediately after submit so that submitted data is not
+     * kept in history. Can be overridden globally via provider config.
+     */
+    discardOnSubmit?: boolean;
+}
+declare function useFormSnapshots(formName: string, options?: FormSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: SyntheticEvent<HTMLFormElement>) => void) => (e: SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+
+interface useFormSnapshotsListOptions {
+    /**
+     * Whether to return only submitted (completed) sessions.
+     * Default: false (both submitted and in-progress).
+     */
+    onlySubmitted?: boolean;
+    /**
+     * Whether to return only successful (2xx) submission results.
+     * Default: false (all statusCode values).
+     */
+    onlySuccessful?: boolean;
+    /**
+     * Maximum age in ms. E.g. last 24 hours = 24 * 60 * 60 * 1000.
+     * Default: unlimited.
+     */
+    maxAgeMs?: number;
+    /**
+     * Maximum number of records to return.
+     * Default: unlimited.
+     */
+    limit?: number;
+}
+interface FormHistoryListItem {
+    id: number;
+    formName: string;
+    createdAt: number;
+    updatedAt: number;
+    submitted: boolean;
+    statusCode: number | null;
+    errorMessage: string | null;
+    /**
+     * Age in ms relative to \"now\".
+     */
+    ageMs: number;
+}
+declare function useFormSnapshotsList(formName: string, options?: useFormSnapshotsListOptions): {
+    items: FormHistoryListItem[];
+    isLoading: boolean;
+};
+
+interface FormSnapshotsGlobalConfig {
+    defaultSnapshotsLimit?: number;
+    /**
+     * Field paths (path/prefix) to exclude while saving snapshots.
+     * E.g. ["password", "patient.address"]
+     */
+    excludeFields?: string[];
+    /**
+     * When true, submitted sessions are discarded and the form is cleared
+     * immediately after submit instead of keeping the data in history.
+     * Can be overridden per form via hook options.
+     */
+    discardOnSubmit?: boolean;
+}
+interface FormSnapshotsProviderProps {
+    value?: FormSnapshotsGlobalConfig;
+    children: ReactNode;
+}
+declare function FormSnapshotsProvider({ value, children, }: Readonly<FormSnapshotsProviderProps>): react_jsx_runtime.JSX.Element;
+declare function useFormSnapshotsConfig(): FormSnapshotsGlobalConfig;
+
+declare function FormSnapshotsDevtools(): react_jsx_runtime.JSX.Element | null;
+
+interface FormSnapshotTableProps {
+    /**
+     * JSON-stringified snapshot. Genellikle `FormSession.data`.
+     */
+    data: string;
+    /**
+     * Message to display when the table is empty.
+     * Default: "No data captured yet."
+     */
+    emptyMessage?: string;
+    /**
+     * Extra class names for the outer wrapper.
+     */
+    className?: string;
+}
+declare function FormSnapshotTable({ data, emptyMessage, className, }: Readonly<FormSnapshotTableProps>): react_jsx_runtime.JSX.Element;
+
+type WithoutSnapshotOverrides = Omit<FormSnapshotsOptions, "getValues" | "applyValues">;
+interface RHFSnapshotsOptions extends WithoutSnapshotOverrides {
+}
+declare function useRHFFormSnapshots<TFieldValues extends Record<string, unknown>>(formName: string, form: UseFormReturn<TFieldValues>, options?: RHFSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => void) => (e: react.SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+interface ObjectStateSnapshotsOptions extends WithoutSnapshotOverrides {
+}
+declare function useObjectFormSnapshots<TState extends Record<string, unknown>>(formName: string, state: TState, setState: (next: TState) => void, options?: ObjectStateSnapshotsOptions): {
+    formRef: react.RefObject<HTMLFormElement>;
+    handleBlur: () => void;
+    wrapSubmit: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => void) => (e: react.SyntheticEvent<HTMLFormElement>) => void;
+    wrapSubmitAsync: (userSubmit?: (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void | {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }>) => (e: react.SyntheticEvent<HTMLFormElement>) => Promise<void>;
+    restoreLatest: () => Promise<void>;
+    isSubmitted: boolean;
+    markSubmitResult: (params: {
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }) => Promise<void>;
+};
+
+declare class FormSnapshotsClient {
+    private readonly storage;
+    private readonly formName;
+    private readonly snapshotsLimit;
+    constructor(params: {
+        storage: FormSnapshotsStorage;
+        formName: string;
+        snapshotsLimit: number;
+    });
+    initSession(): Promise<FormSessionBase>;
+    saveSnapshot(sessionId: number, snapshot: FormSnapshot): Promise<void>;
+    markSubmitted(sessionId: number): Promise<void>;
+    deleteSession(sessionId: number): Promise<void>;
+    setSubmissionResult(params: {
+        sessionId: number;
+        statusCode?: number | null;
+        errorMessage?: string | null;
+    }): Promise<void>;
+    getLatestSnapshot(): Promise<FormSnapshot | null>;
+    openNewSessionFromSnapshot(snapshot: FormSnapshot): Promise<FormSessionBase>;
+}
+
+interface FormSession {
+    id: number;
+    formName: string;
+    /** JSON-serialised record of field name → value */
+    data: string;
+    createdAt: number;
+    updatedAt: number;
+    /** true = the form was submitted; session is closed / read-only */
+    submitted: boolean;
+    /** Optional HTTP-like status code for the last submit attempt */
+    statusCode?: number | null;
+    /** Optional error message when the last submit attempt failed */
+    errorMessage?: string | null;
+}
+declare const db: Dexie & {
+    formSessions: EntityTable<FormSession, "id">;
+};
+
+export { type FormHistoryListItem, type FormSession, type FormSessionBase, type FormSnapshot, FormSnapshotTable, type FormSnapshotTableProps, FormSnapshotsClient, FormSnapshotsDevtools, type FormSnapshotsOptions, FormSnapshotsProvider, type FormSnapshotsProviderProps, type FormSnapshotsStorage, type ObjectStateSnapshotsOptions, type RHFSnapshotsOptions, db, useFormSnapshots, useFormSnapshotsConfig, useFormSnapshotsList, type useFormSnapshotsListOptions, useObjectFormSnapshots, useRHFFormSnapshots };