lemma-sdk 0.2.28 → 0.2.31

package/dist/react/useReverseRelatedRecords.js

@@ -0,0 +1,235 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { parseForeignKeyReference } from "../datastore-query.js";
+import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
+function sentenceCase(value) {
+    return value
+        .replace(/[_\.]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function pickDefaultFields(table, foreignKey) {
+    const names = table.columns
+        .map((column) => column.name)
+        .filter((name) => name !== "created_at" && name !== "updated_at");
+    const prioritized = ["id", "name", "title", "label", "status", foreignKey];
+    const next = [];
+    prioritized.forEach((name) => {
+        if (names.includes(name) && !next.includes(name)) {
+            next.push(name);
+        }
+    });
+    names.forEach((name) => {
+        if (!next.includes(name)) {
+            next.push(name);
+        }
+    });
+    return next.slice(0, 6);
+}
+export function useReverseRelatedRecords({ client, podId, tableName, recordId = null, relation = null, fields, limit = 20, offset, sortBy, order, tablesLimit = 100, enabled = true, autoLoad = true, }) {
+    const [parentTable, setParentTable] = useState(null);
+    const [relatedTable, setRelatedTable] = useState(null);
+    const [parentRecord, setParentRecord] = useState(null);
+    const [relations, setRelations] = useState([]);
+    const [selectedRelation, setSelectedRelation] = useState(null);
+    const [columns, setColumns] = useState([]);
+    const [records, setRecords] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedTableName = tableName.trim();
+    const trimmedRecordId = typeof recordId === "string" ? recordId.trim() : "";
+    const relationKey = stringifyComparable(relation);
+    const fieldsKey = stringifyComparable(fields);
+    const stableRelation = useMemo(() => relation, [relationKey]);
+    const stableFields = useMemo(() => fields, [fieldsKey]);
+    const isEnabled = enabled && trimmedTableName.length > 0 && trimmedRecordId.length > 0;
+    const refresh = useCallback(async (signal) => {
+        if (!isEnabled) {
+            setParentTable(null);
+            setRelatedTable(null);
+            setParentRecord(null);
+            setRelations([]);
+            setSelectedRelation(null);
+            setColumns([]);
+            setRecords([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const [tablesResponse, parentRecordResponse] = await Promise.all([
+                scopedClient.tables.list({ limit: tablesLimit }),
+                scopedClient.records.get(trimmedTableName, trimmedRecordId),
+            ]);
+            if (signal?.aborted)
+                return [];
+            const listedTables = tablesResponse.items ?? [];
+            const nextParentTable = listedTables.find((tableEntry) => tableEntry.name === trimmedTableName)
+                ?? await scopedClient.tables.get(trimmedTableName);
+            const nextParentRecord = parentRecordResponse.data ?? null;
+            if (signal?.aborted)
+                return [];
+            setParentTable(nextParentTable);
+            setParentRecord(nextParentRecord);
+            const nextRelations = listedTables.flatMap((candidateTable) => candidateTable.columns.flatMap((column) => {
+                const reference = column.foreign_key?.references
+                    ? parseForeignKeyReference(column.foreign_key.references)
+                    : null;
+                if (!reference || reference.table !== trimmedTableName) {
+                    return [];
+                }
+                return [{
+                        tableName: candidateTable.name,
+                        foreignKey: column.name,
+                        referencedColumn: reference.column,
+                        label: `${candidateTable.name}.${column.name} -> ${trimmedTableName}.${reference.column}`,
+                    }];
+            }));
+            setRelations(nextRelations);
+            const nextSelectedRelation = stableRelation
+                ? nextRelations.find((entry) => (entry.tableName === stableRelation.tableName
+                    && entry.foreignKey === stableRelation.foreignKey)) ?? null
+                : (nextRelations[0] ?? null);
+            setSelectedRelation(nextSelectedRelation);
+            if (!nextSelectedRelation) {
+                setRelatedTable(null);
+                setColumns([]);
+                setRecords([]);
+                setTotal(0);
+                setNextPageToken(null);
+                return [];
+            }
+            const nextRelatedTable = listedTables.find((tableEntry) => tableEntry.name === nextSelectedRelation.tableName)
+                ?? await scopedClient.tables.get(nextSelectedRelation.tableName);
+            const referenceValue = nextParentRecord?.[nextSelectedRelation.referencedColumn]
+                ?? (nextSelectedRelation.referencedColumn === "id" ? trimmedRecordId : undefined);
+            if (signal?.aborted)
+                return [];
+            setRelatedTable(nextRelatedTable);
+            if (typeof referenceValue === "undefined" || referenceValue === null) {
+                setColumns([]);
+                setRecords([]);
+                setTotal(0);
+                setNextPageToken(null);
+                return [];
+            }
+            const resolvedFields = (stableFields?.length ? stableFields : pickDefaultFields(nextRelatedTable, nextSelectedRelation.foreignKey))
+                .filter((field, index, allFields) => field.trim().length > 0 && allFields.indexOf(field) === index);
+            const response = await scopedClient.records.list(nextSelectedRelation.tableName, {
+                filters: [{
+                        field: nextSelectedRelation.foreignKey,
+                        op: "eq",
+                        value: referenceValue,
+                    }],
+                limit,
+                offset,
+                sortBy,
+                order,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextRecords = (response.items ?? []);
+            setColumns(resolvedFields.map((field) => ({
+                key: field,
+                field,
+                label: sentenceCase(field),
+            })));
+            setRecords(nextRecords);
+            setTotal(response.total ?? nextRecords.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return nextRecords;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(refreshError, "Failed to load reverse-related records.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [
+        client,
+        isEnabled,
+        limit,
+        offset,
+        order,
+        podId,
+        sortBy,
+        stableFields,
+        stableRelation,
+        tablesLimit,
+        trimmedRecordId,
+        trimmedTableName,
+    ]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setParentTable(null);
+            setRelatedTable(null);
+            setParentRecord(null);
+            setRelations([]);
+            setSelectedRelation(null);
+            setColumns([]);
+            setRecords([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load reverse-related records."), "Failed to load reverse-related records."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, isEnabled, refresh]);
+    return useMemo(() => ({
+        parentTable,
+        relatedTable,
+        parentRecord,
+        relations,
+        selectedRelation,
+        columns,
+        records,
+        total,
+        nextPageToken,
+        isLoading,
+        error,
+        refresh,
+    }), [
+        columns,
+        error,
+        isLoading,
+        nextPageToken,
+        parentRecord,
+        parentTable,
+        records,
+        refresh,
+        relatedTable,
+        relations,
+        selectedRelation,
+        total,
+    ]);
+}

package/dist/react/useSchemaForm.d.ts

@@ -0,0 +1,24 @@
+import type { JsonSchemaLike, SchemaFormField } from "../schema-form.js";
+export interface UseSchemaFormOptions {
+    schema?: JsonSchemaLike | null;
+    uiSchema?: Record<string, unknown> | null;
+    initialValues?: Record<string, unknown>;
+    enabled?: boolean;
+    onSubmit?: (data: Record<string, unknown>) => Promise<unknown> | unknown;
+    onError?: (error: unknown) => void;
+}
+export interface UseSchemaFormResult {
+    fields: SchemaFormField[];
+    values: Record<string, unknown>;
+    baselineValues: Record<string, unknown>;
+    fieldErrors: Record<string, string>;
+    isSubmitting: boolean;
+    isDirty: boolean;
+    error: Error | null;
+    setValue: (fieldName: string, value: unknown) => void;
+    setValues: (values: Record<string, unknown>) => void;
+    reset: (nextValues?: Record<string, unknown>) => void;
+    validate: () => boolean;
+    submit: () => Promise<Record<string, unknown> | null>;
+}
+export declare function useSchemaForm({ schema, uiSchema, initialValues, enabled, onSubmit, onError, }: UseSchemaFormOptions): UseSchemaFormResult;

package/dist/react/useSchemaForm.js

@@ -0,0 +1,104 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { buildSchemaFormFields, buildSchemaFormPayload, buildSchemaFormValues, } from "../schema-form.js";
+import { normalizeError, stringifyComparable } from "./utils.js";
+const EMPTY_VALUES = {};
+export function useSchemaForm({ schema = null, uiSchema = null, initialValues = EMPTY_VALUES, enabled = true, onSubmit, onError, }) {
+    const [values, setValuesState] = useState({});
+    const [baselineValues, setBaselineValues] = useState({});
+    const [fieldErrors, setFieldErrors] = useState({});
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const schemaKey = stringifyComparable(schema);
+    const uiSchemaKey = stringifyComparable(uiSchema);
+    const initialValuesKey = stringifyComparable(initialValues);
+    const stableSchema = useMemo(() => schema, [schemaKey]);
+    const stableUiSchema = useMemo(() => uiSchema, [uiSchemaKey]);
+    const stableInitialValues = useMemo(() => initialValues, [initialValuesKey]);
+    const fields = useMemo(() => buildSchemaFormFields(stableSchema ?? undefined, stableUiSchema ?? undefined), [stableSchema, stableUiSchema]);
+    useEffect(() => {
+        if (!enabled) {
+            setValuesState({});
+            setBaselineValues({});
+            setFieldErrors({});
+            setError(null);
+            setIsSubmitting(false);
+            return;
+        }
+        const nextValues = buildSchemaFormValues(stableSchema ?? undefined, stableInitialValues, stableUiSchema ?? undefined);
+        setValuesState(nextValues);
+        setBaselineValues(nextValues);
+        setFieldErrors({});
+    }, [enabled, stableInitialValues, stableSchema, stableUiSchema]);
+    const setValue = useCallback((fieldName, value) => {
+        setValuesState((current) => ({
+            ...current,
+            [fieldName]: value,
+        }));
+        setFieldErrors((current) => {
+            if (!(fieldName in current))
+                return current;
+            const next = { ...current };
+            delete next[fieldName];
+            return next;
+        });
+    }, []);
+    const setValues = useCallback((nextValues) => {
+        setValuesState((current) => ({
+            ...current,
+            ...nextValues,
+        }));
+    }, []);
+    const reset = useCallback((nextValues) => {
+        const resolved = buildSchemaFormValues(stableSchema ?? undefined, nextValues ?? stableInitialValues, stableUiSchema ?? undefined);
+        setValuesState(resolved);
+        setBaselineValues(resolved);
+        setFieldErrors({});
+        setError(null);
+    }, [stableInitialValues, stableSchema, stableUiSchema]);
+    const validate = useCallback(() => {
+        const result = buildSchemaFormPayload(stableSchema ?? undefined, values, stableUiSchema ?? undefined);
+        setFieldErrors(result.errors);
+        return result.isValid;
+    }, [stableSchema, stableUiSchema, values]);
+    const submit = useCallback(async () => {
+        const result = buildSchemaFormPayload(stableSchema ?? undefined, values, stableUiSchema ?? undefined);
+        setFieldErrors(result.errors);
+        if (!result.isValid) {
+            return null;
+        }
+        if (!onSubmit) {
+            return result.data;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            await onSubmit(result.data);
+            setBaselineValues(values);
+            return result.data;
+        }
+        catch (submitError) {
+            const normalized = normalizeError(submitError, "Failed to submit schema form.");
+            setError(normalized);
+            onError?.(submitError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [onError, onSubmit, stableSchema, stableUiSchema, values]);
+    const isDirty = useMemo(() => stringifyComparable(values) !== stringifyComparable(baselineValues), [baselineValues, values]);
+    return useMemo(() => ({
+        fields,
+        values,
+        baselineValues,
+        fieldErrors,
+        isSubmitting,
+        isDirty,
+        error,
+        setValue,
+        setValues,
+        reset,
+        validate,
+        submit,
+    }), [baselineValues, error, fieldErrors, fields, isDirty, isSubmitting, reset, setValue, setValues, submit, validate, values]);
+}

package/dist/react/useTable.d.ts

@@ -0,0 +1,16 @@
+import type { LemmaClient } from "../client.js";
+import type { Table } from "../types.js";
+export interface UseTableOptions {
+    client: LemmaClient;
+    podId?: string;
+    tableName: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+}
+export interface UseTableResult {
+    table: Table | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<Table | null>;
+}
+export declare function useTable({ client, podId, tableName, enabled, autoLoad, }: UseTableOptions): UseTableResult;

package/dist/react/useTable.js

@@ -0,0 +1,70 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useTable({ client, podId, tableName, enabled = true, autoLoad = true, }) {
+    const [table, setTable] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedTableName = tableName.trim();
+    const isEnabled = enabled && trimmedTableName.length > 0;
+    const refresh = useCallback(async (signal) => {
+        if (!isEnabled) {
+            setTable(null);
+            setError(null);
+            setIsLoading(false);
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextTable = await scopedClient.tables.get(trimmedTableName);
+            if (signal?.aborted)
+                return null;
+            setTable(nextTable);
+            return nextTable;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return null;
+            const normalized = normalizeError(refreshError, "Failed to load table.");
+            setError(normalized);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, isEnabled, podId, trimmedTableName]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setTable(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh(controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load table."), "Failed to load table."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, isEnabled, refresh]);
+    return useMemo(() => ({
+        table,
+        isLoading,
+        error,
+        refresh,
+    }), [error, isLoading, refresh, table]);
+}

package/dist/react/useTables.d.ts

@@ -0,0 +1,26 @@
+import type { LemmaClient } from "../client.js";
+import type { Table } from "../types.js";
+export interface UseTablesOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    limit?: number;
+    pageToken?: string;
+}
+export interface UseTablesResult {
+    tables: Table[];
+    total: number;
+    nextPageToken: string | null;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        limit?: number;
+        pageToken?: string;
+    }) => Promise<Table[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<Table[]>;
+}
+export declare function useTables({ client, podId, enabled, autoLoad, limit, pageToken, }: UseTablesOptions): UseTablesResult;

package/dist/react/useTables.js

@@ -0,0 +1,113 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useTables({ client, podId, enabled = true, autoLoad = true, limit = 100, pageToken, }) {
+    const [tables, setTables] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled) {
+            setTables([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.tables.list({
+                limit: overrides.limit ?? limit,
+                pageToken: overrides.pageToken ?? pageToken,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextTables = response.items ?? [];
+            setTables(nextTables);
+            setTotal(response.total ?? nextTables.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return nextTables;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(refreshError, "Failed to load tables.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, limit, pageToken, podId]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!enabled || !nextPageToken || isLoading || isLoadingMore) {
+            return [];
+        }
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.tables.list({
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+            });
+            const moreTables = response.items ?? [];
+            setTables((previous) => [...previous, ...moreTables]);
+            setTotal(response.total ?? tables.length + moreTables.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreTables;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more tables.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, enabled, isLoading, isLoadingMore, limit, nextPageToken, podId, tables.length]);
+    useEffect(() => {
+        if (!enabled) {
+            setTables([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            setIsLoadingMore(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load tables."), "Failed to load tables."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        tables,
+        total,
+        nextPageToken,
+        isLoading,
+        isLoadingMore,
+        error,
+        refresh,
+        loadMore,
+    }), [error, isLoading, isLoadingMore, loadMore, nextPageToken, refresh, tables, total]);
+}

package/dist/react/useTaskSession.js

@@ -2,18 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { parseSSEJson, readSSE } from "../streams.js";
 import { isTerminalTaskStatus, normalizeRunStatus } from "../run-utils.js";
 import { parseTaskStreamEvent, upsertTaskMessage } from "../task-events.js";
-function resolvePodId(client, podId) {
-    const resolved = podId ?? client.podId;
-    if (!resolved) {
-        throw new Error("podId is required. Pass podId or set it on LemmaClient.");
-    }
-    return resolved;
-}
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
+import { normalizeError, resolvePodClient, resolvePodId } from "./utils.js";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -92,8 +81,8 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
         if (!id)
             return null;
         try {
-            client.setPodId(resolvePodId(client, podId));
-            const nextTask = await client.tasks.get(id);
+            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
+            const nextTask = await scopedClient.tasks.get(id);
             setTask(nextTask);
             setTaskStatus(nextTask.status);
             return nextTask;
@@ -110,8 +99,8 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
         if (!id)
             return [];
         try {
-            client.setPodId(resolvePodId(client, podId));
-            const response = await client.tasks.messages.list(id, { limit: 100 });
+            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
+            const response = await scopedClient.tasks.messages.list(id, { limit: 100 });
             const nextMessages = response.items ?? [];
             setMessages(nextMessages);
             return nextMessages;
@@ -141,8 +130,8 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
                     break;
                 }
                 try {
-                    client.setPodId(resolvePodId(client, podId));
-                    const stream = await client.tasks.stream(id, { signal: controller.signal });
+                    const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
+                    const stream = await scopedClient.tasks.stream(id, { signal: controller.signal });
                     reconnectDelayMs = 1000;
                     for await (const event of readSSE(stream)) {
                         if (controller.signal.aborted) {
@@ -201,8 +190,8 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
     }, [client, disconnect, podId, setTaskStatus]);
     const start = useCallback(async (input) => {
         setError(null);
-        client.setPodId(resolvePodId(client, podId));
-        const created = await client.tasks.create({
+        const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
+        const created = await scopedClient.tasks.create({
             agent_name: input.agentName,
             input_data: input.inputData,
         });
@@ -221,8 +210,8 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
         if (!id)
             return null;
         try {
-            client.setPodId(resolvePodId(client, podId));
-            const stopped = await client.tasks.stop(id);
+            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
+            const stopped = await scopedClient.tasks.stop(id);
             setTask(stopped);
             setTaskStatus(stopped.status);
             return stopped;

package/dist/react/useUpdateRecord.d.ts

@@ -0,0 +1,21 @@
+import type { LemmaClient } from "../client.js";
+import type { RecordResponse } from "../types.js";
+export interface UseUpdateRecordOptions {
+    client: LemmaClient;
+    podId?: string;
+    tableName: string;
+    recordId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (record: Record<string, unknown>, response: RecordResponse) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUpdateRecordResult<TRecord extends Record<string, unknown> = Record<string, unknown>> {
+    updatedRecord: TRecord | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    update: (data: Record<string, unknown>, overrides?: {
+        recordId?: string | null;
+    }) => Promise<TRecord | null>;
+    reset: () => void;
+}
+export declare function useUpdateRecord<TRecord extends Record<string, unknown> = Record<string, unknown>>({ client, podId, tableName, recordId, enabled, onSuccess, onError, }: UseUpdateRecordOptions): UseUpdateRecordResult<TRecord>;