velocious 1.0.577 → 1.0.579

package/build/src/frontend-models/base.d.ts

@@ -1,5 +1,163 @@
+import FrontendModelQuery from "./query.js";
+export type FrontendModelRelationship = FrontendModelHasManyRelationship<any, any, any> | FrontendModelSingularRelationship<any, any, any>;
+export type FrontendModelModelEventCallbackEntry = {
+    callback: (payload: {
+        id: string;
+        model: FrontendModelBase;
+    }) => void;
+    eventFilterKey: string | null;
+    eventFilterPayload: import("./query.js").FrontendModelEventFilterPayload | null;
+    projectionPayload: import("./query.js").FrontendModelProjectionPayload;
+};
+export type FrontendModelDestroyEventCallbackEntry = {
+    callback: (payload: {
+        id: string;
+    }) => void;
+};
+export type FrontendModelCommandType = "create" | "find" | "index" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url";
+export type FrontendModelRequestCommandType = FrontendModelCommandType | string;
+export type FrontendModelTransportModelValue = {
+    attributes: () => Record<string, unknown>;
+};
+export type FrontendModelTransportScalarValue = undefined | null | boolean | number | string | bigint | Date | FrontendModelTransportModelValue;
+export type FrontendModelTransportObject = Record<string, unknown>;
+export type FrontendModelTransportValue = FrontendModelTransportScalarValue | FrontendModelTransportObject | Array<unknown>;
+export type FrontendModelAttributeValue = FrontendModelTransportValue;
+export type FrontendModelAttachmentDefinition = {
+    type: "hasOne" | "hasMany";
+};
+export type FrontendModelAttributeDefinition = {
+    columnType?: string;
+    dataType?: string;
+    jsDocType?: string;
+    name?: string;
+    null?: boolean;
+    selectedByDefault?: boolean;
+    sqlType?: string;
+    type?: string;
+};
+export type FrontendModelAttachmentInput = Record<string, ReturnType<typeof JSON.parse>> | {
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    type?: string;
+    name?: string;
+} | null | undefined;
+export type FrontendModelSyncMetadata = Record<string, FrontendModelTransportValue>;
+export type FrontendModelSyncConflictStrategy = "optimisticVersion" | "serverWins" | "lastWriterWins" | "fieldThreeWay" | "appendOnly";
+export type FrontendModelSyncConfig = {
+    enabled: boolean;
+    operations: string[];
+    policyHash: string;
+    policyVersion: string | null;
+    conflictStrategy?: FrontendModelSyncConflictStrategy;
+    metadata?: FrontendModelSyncMetadata;
+};
+export type FrontendModelResourceConfig = {
+    attributes?: Array<string | FrontendModelAttributeDefinition> | Record<string, FrontendModelAttributeDefinition>;
+    builtInCollectionCommands?: string[];
+    builtInMemberCommands?: string[];
+    collectionCommands?: string[];
+    commands?: string[];
+    memberCommands?: string[];
+    attachments?: Record<string, FrontendModelAttachmentDefinition>;
+    modelName?: string;
+    nestedAttributes?: Record<string, {
+        allowDestroy?: boolean;
+        limit?: number;
+    }>;
+    primaryKey?: string;
+    relationships?: string[];
+    sync?: FrontendModelSyncConfig;
+};
+export type FrontendModelConstructor<T extends FrontendModelBase = FrontendModelBase> = {
+    new (attributes?: Record<string, FrontendModelAttributeValue>): T;
+};
+export type FrontendModelClass<T extends FrontendModelBase = FrontendModelBase<any, any, any>, Attributes extends object = any, CreateAttributes extends object = any> = {
+    new (): T;
+    create(attributes?: CreateAttributes): Promise<T>;
+} & Omit<typeof FrontendModelBase, "create" | "prototype">;
+export type FrontendModelCreateAttributesFor<T extends FrontendModelBase> = T extends FrontendModelBase<Record<string, FrontendModelAttributeValue>, infer CreateAttributes, infer _UpdateAttributes> ? CreateAttributes : Record<string, FrontendModelAttributeValue>;
+export type FrontendModelRelationshipModel<T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase> = T extends typeof FrontendModelBase ? InstanceType<T> : T;
+export type FrontendModelTransportConfig = {
+    /**
+     * - Optional frontend-model URL. This should be the shared endpoint (for example `"/frontend-models"` or `"https://example.com/frontend-models"`).
+     */
+    url?: string | (() => string | undefined | null);
+    /**
+     * - Deprecated shared-endpoint flag retained for compatibility. Frontend-model CRUD/custom commands use the shared frontend-model API envelope by default.
+     */
+    shared?: boolean;
+    /**
+     * - Optional websocket URL. When set, Velocious creates and manages its own websocket client internally. Subscriptions use the websocket; CRUD uses HTTP and falls back gracefully. Example: `"ws://localhost:3006/websocket"`.
+     */
+    websocketUrl?: string | (() => string | undefined | null);
+    /**
+     * - Optional websocket client for shared frontend-model API requests and subscriptions. Its `post` receives the bounded-deadline `signal` and should forward it into the underlying transport so the deadline can abort the live request and its response-body read.
+     */
+    websocketClient?: {
+        post: (path: string, body?: ReturnType<typeof JSON.parse>, options?: {
+            headers?: Record<string, string>;
+            signal?: AbortSignal;
+        }) => Promise<{
+            json: () => ReturnType<typeof JSON.parse>;
+        }>;
+        subscribe: (channel: string, options: {
+            params?: Record<string, ReturnType<typeof JSON.parse>>;
+        }, callback: (payload: ReturnType<typeof JSON.parse>) => void) => (() => void);
+        subscribeAndWait?: (channel: string, options: {
+            params?: Record<string, ReturnType<typeof JSON.parse>>;
+        }, callback: (payload: ReturnType<typeof JSON.parse>) => void) => Promise<(() => void)>;
+    };
+    /**
+     * - Extra HTTP/WS headers to attach to every frontend-model API request. Pass a function to compute them at request time (for example to include the current locale).
+     */
+    requestHeaders?: Record<string, string> | (() => Record<string, string>);
+    /**
+     * - Bounded deadline in milliseconds covering connection, response headers, and response-body consumption for each frontend-model API request. On expiry the live fetch/adapter request is aborted (built on awaitery's `timeout`) and awaitery's `TimeoutError` is thrown, so callers can classify a timeout via `error instanceof TimeoutError`. Pass a function to resolve it per request. Falsy/absent means no deadline.
+     */
+    timeout?: number | (() => number | undefined | null);
+    /**
+     * - Optional caller/session AbortSignal composed with the deadline. Aborting it cancels the live request (for example on session shutdown or offline transition); the resulting abort error stays distinguishable from a timeout. Pass a function to resolve the current signal per request.
+     */
+    signal?: AbortSignal | (() => AbortSignal | undefined | null);
+    /**
+     * - Optional sessionId persistence hook forwarded to the internal `VelociousWebsocketClient` so WS sessions can be resumed across page reloads / app restarts.
+     */
+    sessionStore?: {
+        get: () => string | null | undefined | Promise<string | null | undefined>;
+        set: (sessionId: string) => void | Promise<void>;
+        clear: () => void | Promise<void>;
+    };
+    /**
+     * - IANA timezone sent with every frontend-model API request for timezone-less datetime parsing.
+     */
+    timeZone?: string | (() => string | null | undefined);
+    /**
+     * - Offline mutation queue configuration.
+     */
+    offlineSync?: {
+        actorDeviceId: string;
+        actorUserId: string;
+        clientMutationId?: () => string;
+        enabled?: boolean;
+        mutationLog: import("../sync/local-mutation-log.js").default;
+        now?: () => Date;
+        offlineGrant: {
+            id: string;
+        };
+    };
+};
+export type FrontendModelIdleWaitArgs = {
+    /**
+     * - Milliseconds the transport must stay idle before resolving.
+     */
+    quietMs?: number;
+    /**
+     * - Timeout in milliseconds.
+     */
+    timeout?: number;
+};
 /** Error raised when reading an attribute that was not selected in query payloads. */
-export class AttributeNotSelectedError extends Error {
+export declare class AttributeNotSelectedError extends Error {
     /**
      * Runs constructor.
      * @param {string} modelName - Model class name.
@@ -13,7 +171,13 @@ export class AttributeNotSelectedError extends Error {
  * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} T
  * @template {object} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
  */
-export class FrontendModelSingularRelationship<S extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, TargetCreateAttributes extends object = Record<string, FrontendModelTransportValue>> {
+export declare class FrontendModelSingularRelationship<S extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, TargetCreateAttributes extends object = Record<string, FrontendModelAttributeValue>> {
+    model: FrontendModelBase<any, any, any>;
+    relationshipName: string;
+    targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelTransportValue>, TargetCreateAttributes> | null;
+    _preloaded: boolean;
+    /** @type {FrontendModelRelationshipModel<T> | null} */
+    _loadedValue: FrontendModelRelationshipModel<T> | null;
     /**
      * Runs constructor.
      * @param {FrontendModelBase} model - Parent model.
@@ -21,12 +185,6 @@ export class FrontendModelSingularRelationship<S extends FrontendModelBase<any,
      * @param {FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelAttributeValue>, TargetCreateAttributes> | null} targetModelClass - Target model class.
      */
     constructor(model: FrontendModelBase, relationshipName: string, targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelAttributeValue>, TargetCreateAttributes> | null);
-    model: FrontendModelBase<any, any, any>;
-    relationshipName: string;
-    targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelTransportValue>, TargetCreateAttributes> | null;
-    _preloaded: boolean;
-    /** @type {FrontendModelRelationshipModel<T> | null} */
-    _loadedValue: FrontendModelRelationshipModel<T> | null;
     /**
      * Runs set loaded.
      * @param {FrontendModelRelationshipModel<T> | null | undefined} loadedValue - Loaded relationship value.
@@ -72,7 +230,15 @@ export class FrontendModelSingularRelationship<S extends FrontendModelBase<any,
  * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} T
  * @template {object} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
  */
-export class FrontendModelHasManyRelationship<S extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, TargetCreateAttributes extends object = Record<string, FrontendModelTransportValue>> {
+export declare class FrontendModelHasManyRelationship<S extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase, TargetCreateAttributes extends object = Record<string, FrontendModelAttributeValue>> {
+    model: FrontendModelBase<any, any, any>;
+    relationshipName: string;
+    targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelTransportValue>, TargetCreateAttributes> | null;
+    _preloaded: boolean;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Array<FrontendModelRelationshipModel<T>>} */
+    _loadedValue: Array<FrontendModelRelationshipModel<T>>;
     /**
      * Runs constructor.
      * @param {FrontendModelBase} model - Parent model.
@@ -80,14 +246,6 @@ export class FrontendModelHasManyRelationship<S extends FrontendModelBase<any, a
      * @param {FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelAttributeValue>, TargetCreateAttributes> | null} targetModelClass - Target model class.
      */
     constructor(model: FrontendModelBase, relationshipName: string, targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelAttributeValue>, TargetCreateAttributes> | null);
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Array<FrontendModelRelationshipModel<T>>} */
-    _loadedValue: Array<FrontendModelRelationshipModel<T>>;
-    model: FrontendModelBase<any, any, any>;
-    relationshipName: string;
-    targetModelClass: FrontendModelClass<FrontendModelRelationshipModel<T>, Record<string, FrontendModelTransportValue>, TargetCreateAttributes> | null;
-    _preloaded: boolean;
     /**
      * Runs set loaded.
      * @param {Array<FrontendModelRelationshipModel<T>>} loadedValue - Loaded relationship value.
@@ -140,7 +298,13 @@ export class FrontendModelHasManyRelationship<S extends FrontendModelBase<any, a
 /**
  * Downloaded frontend-model attachment payload wrapper.
  */
-export class FrontendModelAttachmentDownload {
+export declare class FrontendModelAttachmentDownload {
+    idValue: string;
+    filenameValue: string;
+    contentTypeValue: string | null;
+    byteSizeValue: number;
+    contentValue: Uint8Array<ArrayBufferLike>;
+    urlValue: string | null;
     /**
      * Runs constructor.
      * @param {object} args - Options.
@@ -157,14 +321,8 @@ export class FrontendModelAttachmentDownload {
         contentType: string | null;
         byteSize: number;
         content: Uint8Array;
-        url?: string | null | undefined;
+        url?: string | null;
     });
-    idValue: string;
-    filenameValue: string;
-    contentTypeValue: string | null;
-    byteSizeValue: number;
-    contentValue: Uint8Array<ArrayBufferLike>;
-    urlValue: string | null;
     /**
      * Runs byte size.
      * @returns {number} - File size in bytes.
@@ -199,7 +357,14 @@ export class FrontendModelAttachmentDownload {
 /**
  * Frontend-model attachment helper for one attachment name.
  */
-export class FrontendModelAttachmentHandle {
+export declare class FrontendModelAttachmentHandle {
+    model: FrontendModelBase<any, any, any>;
+    attachmentName: string;
+    /**
+     * Pending attachment inputs queued for the next model save.
+     * @type {FrontendModelAttachmentInput[]}
+     */
+    pendingInputs: FrontendModelAttachmentInput[];
     /**
      * Runs constructor.
      * @param {object} args - Options.
@@ -210,13 +375,6 @@ export class FrontendModelAttachmentHandle {
         model: FrontendModelBase;
         attachmentName: string;
     });
-    /**
-     * Pending attachment inputs queued for the next model save.
-     * @type {FrontendModelAttachmentInput[]}
-     */
-    pendingInputs: FrontendModelAttachmentInput[];
-    model: FrontendModelBase<any, any, any>;
-    attachmentName: string;
     /**
      * Queue attachment input for the parent model's next save.
      * @param {FrontendModelAttachmentInput | FrontendModelAttachmentInput[]} input - Attachment input.
@@ -230,17 +388,17 @@ export class FrontendModelAttachmentHandle {
     hasPendingAttachments(): boolean;
     /**
      * Builds the save payload for queued attachment inputs.
-     * @returns {Promise<Record<string, ?> | Record<string, ?>[] | undefined>} Normalized attachment payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | Record<string, ReturnType<typeof JSON.parse>>[] | undefined>} Normalized attachment payload.
      */
-    pendingAttachmentsPayload(): Promise<Record<string, unknown> | Record<string, unknown>[] | undefined>;
+    pendingAttachmentsPayload(): Promise<Record<string, ReturnType<typeof JSON.parse>> | Record<string, ReturnType<typeof JSON.parse>>[] | undefined>;
     /** Clears queued attachment inputs after a successful model save. */
     clearPendingAttachments(): void;
     /**
      * Runs attach.
-     * @param {?} input - Attachment input.
+     * @param {ReturnType<typeof JSON.parse>} input - Attachment input.
      * @returns {Promise<void>} - Resolves when attached.
      */
-    attach(input: unknown): Promise<void>;
+    attach(input: ReturnType<typeof JSON.parse>): Promise<void>;
     /**
      * Runs download.
      * @param {string} [attachmentId] - Optional attachment id for has-many attachments.
@@ -301,6 +459,7 @@ export class FrontendModelAttachmentHandle {
  * @template {object} [UpdateAttributes=any]
  */
 export default class FrontendModelBase<Attributes extends object = any, CreateAttributes extends object = any, UpdateAttributes extends object = any> {
+    static _generatedAttachmentMethods: boolean | undefined;
     /**
      * Narrows the runtime value to the documented type.
      * @type {string | undefined} */
@@ -321,12 +480,55 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @returns {void}
      */
     static setAutoload(newValue: boolean): void;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Record<string, FrontendModelAttributeValue>} */
+    _attributes: Record<string, FrontendModelAttributeValue>;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Record<string, FrontendModelHasManyRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>> | FrontendModelSingularRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>>>} */
+    _relationships: Record<string, FrontendModelHasManyRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>> | FrontendModelSingularRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>>>;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Record<string, FrontendModelAttachmentHandle>} */
+    _attachments: Record<string, FrontendModelAttachmentHandle>;
+    /**
+     * Rails-style nested attribute payloads queued for the next save.
+     * @type {Record<string, ReturnType<typeof JSON.parse>>}
+     */
+    _pendingNestedAttributes: Record<string, ReturnType<typeof JSON.parse>>;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Set<string> | null} */
+    _selectedAttributes: Set<string> | null;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {boolean} */
+    _isNewRecord: boolean;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {boolean} */
+    _markedForDestruction: boolean;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Record<string, FrontendModelAttributeValue>} */
+    _persistedAttributes: Record<string, FrontendModelAttributeValue>;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {Array<FrontendModelBase> | undefined} - Shared reference to sibling records loaded in the same batch. Used by auto-batch-preload.
+     */
+    _loadCohort: Array<FrontendModelBase> | undefined;
+    /**
+     * Runs constructor.
+     * @param {Attributes | CreateAttributes} [attributes] - Initial attributes.
+     */
+    constructor(attributes?: Attributes | CreateAttributes);
     /**
      * Runs ensure generated attachment methods.
      * @this {FrontendModelClass}
      * @returns {void} - Ensures attachment helper methods exist on the prototype.
      */
-    static ensureGeneratedAttachmentMethods(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): void;
+    static ensureGeneratedAttachmentMethods(this: FrontendModelClass): void;
     /**
      * Runs resource config.
      * @returns {FrontendModelResourceConfig} - Resource configuration.
@@ -337,7 +539,7 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @this {FrontendModelClass}
      * @returns {Record<string, FrontendModelClass | string>} - Relationship model classes (or class name strings) keyed by relationship name.
      */
-    static relationshipModelClasses(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): Record<string, FrontendModelClass | string>;
+    static relationshipModelClasses(this: FrontendModelClass): Record<string, FrontendModelClass | string>;
     /**
      * Register a frontend model class so it can be resolved by name in relationship lookups.
      * @param {FrontendModelClass} modelClass - Model class to register.
@@ -346,11 +548,11 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
     static registerModel(modelClass: FrontendModelClass): void;
     /**
      * Runs define scope.
-     * @param {(...args: Array<?>) => ?} callback - Scope callback.
-     * @returns {((...args: Array<?>) => import("./query.js").default<FrontendModelClass>) & {scope: (...args: Array<?>) => import("../utils/model-scope.js").ModelScopeDescriptor}} - Scope helper.
+     * @param {(...args: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>} callback - Scope callback.
+     * @returns {((...args: Array<ReturnType<typeof JSON.parse>>) => import("./query.js").default<FrontendModelClass>) & {scope: (...args: Array<ReturnType<typeof JSON.parse>>) => import("../utils/model-scope.js").ModelScopeDescriptor}} - Scope helper.
      */
-    static defineScope(callback: (...args: Array<unknown>) => unknown): ((...args: Array<unknown>) => import("./query.js").default<FrontendModelClass>) & {
-        scope: (...args: Array<unknown>) => import("../utils/model-scope.js").ModelScopeDescriptor;
+    static defineScope(callback: (...args: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>): ((...args: Array<ReturnType<typeof JSON.parse>>) => import("./query.js").default<FrontendModelClass>) & {
+        scope: (...args: Array<ReturnType<typeof JSON.parse>>) => import("../utils/model-scope.js").ModelScopeDescriptor;
     };
     /**
      * Resolve a relationship model class value that may be a class reference or a string name.
@@ -363,7 +565,7 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @this {FrontendModelClass}
      * @returns {Record<string, {type: "belongsTo" | "hasOne" | "hasMany", autoload?: boolean}>} - Relationship definitions keyed by relationship name.
      */
-    static relationshipDefinitions(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): Record<string, {
+    static relationshipDefinitions(this: FrontendModelClass): Record<string, {
         type: "belongsTo" | "hasOne" | "hasMany";
         autoload?: boolean;
     }>;
@@ -372,21 +574,21 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @this {FrontendModelClass}
      * @returns {Record<string, FrontendModelAttachmentDefinition>} - Attachment definitions keyed by attachment name.
      */
-    static attachmentDefinitions(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): Record<string, FrontendModelAttachmentDefinition>;
+    static attachmentDefinitions(this: FrontendModelClass): Record<string, FrontendModelAttachmentDefinition>;
     /**
      * Runs attachment definition.
      * @this {FrontendModelClass}
      * @param {string} attachmentName - Attachment name.
      * @returns {FrontendModelAttachmentDefinition | null} - Attachment definition.
      */
-    static attachmentDefinition(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, attachmentName: string): FrontendModelAttachmentDefinition | null;
+    static attachmentDefinition(this: FrontendModelClass, attachmentName: string): FrontendModelAttachmentDefinition | null;
     /**
      * Runs relationship definition.
      * @this {FrontendModelClass}
      * @param {string} relationshipName - Relationship name.
      * @returns {{type: "belongsTo" | "hasOne" | "hasMany", autoload?: boolean} | null} - Relationship definition.
      */
-    static relationshipDefinition(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, relationshipName: string): {
+    static relationshipDefinition(this: FrontendModelClass, relationshipName: string): {
         type: "belongsTo" | "hasOne" | "hasMany";
         autoload?: boolean;
     } | null;
@@ -396,40 +598,248 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {string} attributeName - Candidate attribute name, such as `tasksAttributes`.
      * @returns {string | null} Relationship name when nested attributes are configured.
      */
-    static nestedAttributesRelationshipName(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, attributeName: string): string | null;
+    static nestedAttributesRelationshipName(this: FrontendModelClass, attributeName: string): string | null;
     /**
      * Runs relationship model class.
      * @this {FrontendModelClass}
      * @param {string} relationshipName - Relationship name.
      * @returns {FrontendModelClass | null} - Target relationship model class.
      */
-    static relationshipModelClass(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, relationshipName: string): FrontendModelClass | null;
+    static relationshipModelClass(this: FrontendModelClass, relationshipName: string): FrontendModelClass | null;
     /**
-     * Runs primary key.
-     * @this {FrontendModelClass}
-     * @returns {string} - Primary key name.
+     * Runs attributes.
+     * @returns {Attributes} - Attributes hash.
      */
-    static primaryKey(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): string;
+    attributes(): Attributes;
     /**
-     * Runs resource path.
-     * @this {FrontendModelClass}
-     * @returns {string} - Derived resource path.
+     * Runs is new record.
+     * @returns {boolean} - Whether this model has not yet been persisted.
      */
-    static resourcePath(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): string;
+    isNewRecord(): boolean;
     /**
-     * Runs command name.
-     * @this {FrontendModelClass}
-     * @param {FrontendModelCommandType} commandType - Command type.
-     * @returns {string} - Resolved command name.
+     * Runs is persisted.
+     * @returns {boolean} - Whether this model has been persisted.
      */
-    static commandName(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, commandType: FrontendModelCommandType): string;
+    isPersisted(): boolean;
     /**
-     * Runs normalize custom command payload arguments.
+     * Runs set is new record.
+     * @param {boolean} newIsNewRecord - New persisted-state flag.
+     * @returns {void}
+     */
+    setIsNewRecord(newIsNewRecord: boolean): void;
+    /**
+     * Marks this record for destruction when its parent is next saved through
+     * nested-attribute support. The record is not removed from the parent's
+     * relationship collection until the server confirms the delete.
+     * @returns {void} - No return value.
+     */
+    markForDestruction(): void;
+    /**
+     * Runs marked for destruction.
+     * @returns {boolean} - Whether this record is queued for nested destruction on next parent save.
+     */
+    markedForDestruction(): boolean;
+    /**
+     * Runs changes.
+     * @returns {Record<string, Array<ReturnType<typeof JSON.parse>>>} - Changed attributes as `[oldValue, newValue]`.
+     */
+    changes(): Record<string, Array<ReturnType<typeof JSON.parse>>>;
+    /**
+     * Runs is changed.
+     * @returns {boolean} - Whether any tracked attribute has changed.
+     */
+    isChanged(): boolean;
+    /**
+     * Runs get relationship by name.
+     * @param {string} relationshipName - Relationship name.
+     * @returns {FrontendModelRelationship} - Relationship state object.
+     */
+    getRelationshipByName(relationshipName: string): FrontendModelRelationship;
+    /**
+     * Runs get attachment by name.
+     * @param {string} attachmentName - Attachment name.
+     * @returns {FrontendModelAttachmentHandle} - Attachment helper.
+     */
+    getAttachmentByName(attachmentName: string): FrontendModelAttachmentHandle;
+    /**
+     * Runs load relationship.
+     * @param {string} relationshipName - Relationship name.
+     * @returns {Promise<FrontendModelBase | Array<FrontendModelBase> | null>} - Loaded relationship value.
+     */
+    loadRelationship(relationshipName: string): Promise<FrontendModelBase | Array<FrontendModelBase> | null>;
+    /**
+     * Preloads relationship(s) onto this already-loaded record. Accepts either a
+     * query built via `Model.preload(...).select(...)` or a raw preload spec
+     * (string / array / nested object). Relationships already preloaded with the
+     * required columns present are left untouched unless `force` is set. Carries
+     * the query's preload graph, select, selectsExtra, withCount, abilities, and
+     * queryData when re-fetching.
+     * @param {import("./query.js").default<FrontendModelClass> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} queryOrSpec - Preload source.
+     * @param {{force?: boolean}} [options] - Options.
+     * @returns {Promise<void>} - Resolves when preloading completes.
+     */
+    preload(queryOrSpec: import("./query.js").default<FrontendModelClass> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Runs relationship or load.
+     * @param {string} relationshipName - Relationship name.
+     * @returns {Promise<FrontendModelBase | Array<FrontendModelBase> | null>} - Loaded relationship value.
+     */
+    relationshipOrLoad(relationshipName: string): Promise<FrontendModelBase | Array<FrontendModelBase> | null>;
+    /**
+     * Attempts to batch-load `relationshipName` across cohort siblings via a
+     * single `preload([name]).where({pk: [ids]}).toArray()` request, then copies
+     * the preloaded relationship state onto each sibling. Returns true when a
+     * batch ran, false when autoload is off, there is no cohort, or no batch
+     * candidates remain. Siblings whose relationship state is already set
+     * (preloaded or locally manipulated via `build` / `setRelationship`) are
+     * skipped so their cached/edited value is preserved.
+     * @param {string} relationshipName - Relationship name.
+     * @returns {Promise<boolean>} - Whether a cohort batch preload ran.
+     */
+    _tryCohortPreload(relationshipName: string): Promise<boolean>;
+    /**
+     * Runs set relationship.
+     * @param {string} relationshipName - Relationship name.
+     * @param {FrontendModelBase | null | undefined} relationshipValue - Relationship value.
+     * @returns {FrontendModelBase | null | undefined} - Assigned relationship value.
+     */
+    setRelationship(relationshipName: string, relationshipValue: FrontendModelBase | null | undefined): FrontendModelBase | null | undefined;
+    /**
+     * Runs assign attributes.
+     * @param {Attributes | CreateAttributes | UpdateAttributes | Record<string, FrontendModelAttributeValue>} attributes - Attributes to assign.
+     * @returns {void} - No return value.
+     */
+    assignAttributes(attributes: Attributes | CreateAttributes | UpdateAttributes | Record<string, FrontendModelAttributeValue>): void;
+    /**
+     * Runs clear relationship cache.
+     * @returns {void} - Clears cached relationship state.
+     */
+    clearRelationshipCache(): void;
+    /**
+     * Runs primary key.
+     * @this {FrontendModelClass}
+     * @returns {string} - Primary key name.
+     */
+    static primaryKey(this: FrontendModelClass): string;
+    /**
+     * Runs primary key value.
+     * @returns {number | string} - Primary key value.
+     */
+    primaryKeyValue(): number | string;
+    /**
+     * Runs read attribute.
+     * @param {string} attributeName - Attribute name.
+     * @returns {ReturnType<typeof JSON.parse>} - Attribute value.
+     */
+    readAttribute(attributeName: string): ReturnType<typeof JSON.parse>;
+    /**
+     * Whether an attribute value is currently loaded on this record. Used by the
+     * preloader to decide whether a relationship can be skipped because the
+     * requested columns are already present.
+     * @param {string} attributeName - Attribute name.
+     * @returns {boolean} - Whether the attribute is loaded.
+     */
+    hasLoadedAttribute(attributeName: string): boolean;
+    /**
+     * Read an association count attached by `.withCount(...)`. Counts
+     * live on a dedicated map separate from the record's attributes so
+     * a virtual count like `tasksCount` can't silently shadow a real
+     * column of the same name. Returns the attached value, or 0 when
+     * `.withCount(...)` wasn't requested for this attribute.
+     * @param {string} attributeName - Attribute name, e.g. `"tasksCount"` or a custom name from `.withCount({customName: {...}})`.
+     * @returns {number} - Attached association count, or zero when absent.
+     */
+    readCount(attributeName: string): number;
+    /**
+     * Internal setter called by `instantiateFromResponse` when hydrating
+     * association counts that rode along with the record payload.
+     * @param {string} attributeName - Attribute name.
+     * @param {number} value - Count value.
+     * @returns {void}
+     */
+    _setAssociationCount(attributeName: string, value: number): void;
+    /**
+     * Read a per-record ability result attached by `.abilities(...)`. The
+     * backend evaluates each requested action against the current
+     * ability for this record instance and ships the result alongside
+     * the record's attributes. Returns `false` when the action wasn't
+     * requested (or the ability denied it), so UI code can safely branch
+     * on `record.can("update")` without first checking whether the
+     * ability was loaded.
+     * @param {string} action - Ability action name, e.g. `"update"`.
+     * @returns {boolean} - Whether the requested ability is allowed.
+     */
+    can(action: string): boolean;
+    /**
+     * Internal setter called by `instantiateFromResponse` when hydrating
+     * per-record ability results that rode along with the record
+     * payload.
+     * @param {string} action - Ability action name.
+     * @param {boolean} value - Whether the current ability permits the action on this record.
+     * @returns {void}
+     */
+    _setComputedAbility(action: string, value: boolean): void;
+    /**
+     * Read a consumer-defined value attached by `.queryData(...)`. Stored
+     * on a dedicated map rather than `_attributes`, so a virtual alias
+     * like `tasksCount` cannot silently shadow a real column of the same
+     * name. Returns `null` when no registered fn produced that alias for
+     * this record (e.g. no child rows matched the aggregate).
+     * @param {string} name - queryData alias name.
+     * @returns {ReturnType<typeof JSON.parse>} - Attached query-data value.
+     */
+    queryData(name: string): ReturnType<typeof JSON.parse>;
+    /**
+     * Internal setter used by `instantiateFromResponse` when hydrating
+     * queryData values that rode along with the record payload.
+     * @param {string} name - queryData alias name.
+     * @param {ReturnType<typeof JSON.parse>} value - Attached value.
+     * @returns {void}
+     */
+    _setQueryData(name: string, value: ReturnType<typeof JSON.parse>): void;
+    /**
+     * Runs set attribute.
+     * @param {string} attributeName - Attribute name.
+     * @param {ReturnType<typeof JSON.parse>} newValue - New value.
+     * @returns {ReturnType<typeof JSON.parse>} - Assigned value.
+     */
+    setAttribute(attributeName: string, newValue: ReturnType<typeof JSON.parse>): ReturnType<typeof JSON.parse>;
+    /**
+     * Invalidates any cached belongsTo relationship whose foreign key matches the
+     * changed attribute. HasMany / hasOne relationships are left untouched because
+     * their foreign key lives on the child, not on this model, and blanket-clearing
+     * them would destroy nested-save state and preloaded children the caller never
+     * asked to invalidate.
+     *
+     * Foreign keys are inferred when not declared: for belongsTo `projectId` is
+     * inferred from relationship name `project`. Explicit `foreignKey` on the
+     * relationship definition takes precedence.
+     * @param {string} attributeName - Attribute name that changed.
+     * @returns {void}
+     */
+    _invalidateRelationshipsForAttribute(attributeName: string): void;
+    /**
+     * Runs resource path.
+     * @this {FrontendModelClass}
+     * @returns {string} - Derived resource path.
+     */
+    static resourcePath(this: FrontendModelClass): string;
+    /**
+     * Runs command name.
+     * @this {FrontendModelClass}
+     * @param {FrontendModelCommandType} commandType - Command type.
+     * @returns {string} - Resolved command name.
+     */
+    static commandName(this: FrontendModelClass, commandType: FrontendModelCommandType): string;
+    /**
+     * Runs normalize custom command payload arguments.
      * @this {FrontendModelClass}
-     * @param {Array<?>} args - Command arguments.
-     * @returns {Record<string, ?>} - Command payload.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Command arguments.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Command payload.
      */
-    static normalizeCustomCommandPayloadArguments(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, args: Array<unknown>): Record<string, unknown>;
+    static normalizeCustomCommandPayloadArguments(this: FrontendModelClass, args: Array<ReturnType<typeof JSON.parse>>): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Returns the model name, preferring an explicit `static modelName` declaration
      * over the JavaScript class `.name` property. This allows minified builds to
@@ -437,7 +847,7 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @this {FrontendModelClass}
      * @returns {string} - The model name.
      */
-    static getModelName(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): string;
+    static getModelName(this: FrontendModelClass): string;
     /**
      * Runs configure transport.
      * @param {FrontendModelTransportConfig} config - Frontend model transport configuration.
@@ -484,10 +894,10 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Sets global metadata on the WebSocket connection. Sent to the server immediately
      * over WebSocket and exposed to WebSocket-borne requests as request metadata.
      * @param {string} key - Metadata key.
-     * @param {?} value - Metadata value (null to clear).
+     * @param {ReturnType<typeof JSON.parse>} value - Metadata value (null to clear).
      * @returns {void}
      */
-    static setWebsocketMetadata(key: string, value: unknown): void;
+    static setWebsocketMetadata(key: string, value: ReturnType<typeof JSON.parse>): void;
     /**
      * Opens a managed connection that auto-opens, auto-closes, and
      * auto-reconnects based on `shouldConnect()` and `params()`.
@@ -495,14 +905,14 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * functions change (e.g. current-user sign-in/out). The handle
      * retries when the WS client isn't ready and reopens on close.
      * @param {string} connectionType - Connection class name registered on the server.
-     * @param {{shouldConnect: () => boolean, params: () => Record<string, ?>, signal?: AbortSignal, onMessage?: (body: ?) => void}} options - Connection lifecycle, cancellation, and payload callbacks.
+     * @param {{shouldConnect: () => boolean, params: () => Record<string, ReturnType<typeof JSON.parse>>, signal?: AbortSignal, onMessage?: (body: ReturnType<typeof JSON.parse>) => void}} options - Connection lifecycle, cancellation, and payload callbacks.
      * @returns {{sync: () => void, close: () => void}} - Handle used to resync or close the managed connection.
      */
     static openManagedConnection(connectionType: string, options: {
         shouldConnect: () => boolean;
-        params: () => Record<string, unknown>;
+        params: () => Record<string, ReturnType<typeof JSON.parse>>;
         signal?: AbortSignal;
-        onMessage?: (body: unknown) => void;
+        onMessage?: (body: ReturnType<typeof JSON.parse>) => void;
     }): {
         sync: () => void;
         close: () => void;
@@ -513,11 +923,11 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * `openConnection`. Apps use this for per-session state/messaging
      * that doesn't fit the pub/sub Channel model (locale, presence).
      * @param {string} connectionType - Name the server registered the class under.
-     * @param {{params?: Record<string, ?>, timeoutMs?: number, signal?: AbortSignal, onConnect?: () => void, onMessage?: (body: Record<string, unknown>) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Connection options, readiness controls, and event handlers. Connect the client first; the timeout covers server-confirmed readiness and the signal cancels readiness without entering the wire payload.
+     * @param {{params?: Record<string, ReturnType<typeof JSON.parse>>, timeoutMs?: number, signal?: AbortSignal, onConnect?: () => void, onMessage?: (body: Record<string, unknown>) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Connection options, readiness controls, and event handlers. Connect the client first; the timeout covers server-confirmed readiness and the signal cancels readiness without entering the wire payload.
      * @returns {{ready: Promise<void>, close: () => void}} - Websocket connection handle.
      */
     static openWebsocketConnection(connectionType: string, options?: {
-        params?: Record<string, unknown>;
+        params?: Record<string, ReturnType<typeof JSON.parse>>;
         timeoutMs?: number;
         signal?: AbortSignal;
         onConnect?: () => void;
@@ -533,11 +943,11 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Subscribes to a pub/sub `WebsocketChannel`. Thin wrapper around
      * the internal client's `subscribeChannel`.
      * @param {string} channelType - Channel class name registered on the server.
-     * @param {{params?: Record<string, ?>, timeoutMs?: number, signal?: AbortSignal, onMessage?: (body: Record<string, unknown>) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Channel options, startup controls, and event handlers. The timeout covers connect and server-confirmed readiness only; the signal cancels startup without entering the wire payload.
+     * @param {{params?: Record<string, ReturnType<typeof JSON.parse>>, timeoutMs?: number, signal?: AbortSignal, onMessage?: (body: Record<string, unknown>) => void, onDisconnect?: () => void, onResume?: () => void, onClose?: (reason: string) => void}} [options] - Channel options, startup controls, and event handlers. The timeout covers connect and server-confirmed readiness only; the signal cancels startup without entering the wire payload.
      * @returns {{ready: Promise<void>, close: () => void}} - Websocket channel handle from the configured client.
      */
     static subscribeWebsocketChannel(channelType: string, options?: {
-        params?: Record<string, unknown>;
+        params?: Record<string, ReturnType<typeof JSON.parse>>;
         timeoutMs?: number;
         signal?: AbortSignal;
         onMessage?: (body: Record<string, unknown>) => void;
@@ -560,14 +970,14 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {object} response - Response payload.
      * @returns {Record<string, FrontendModelAttributeValue>} - Attributes from payload.
      */
-    static attributesFromResponse(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, response: object): Record<string, FrontendModelAttributeValue>;
+    static attributesFromResponse(this: FrontendModelClass, response: object): Record<string, FrontendModelAttributeValue>;
     /**
      * Runs model data from response.
      * @this {FrontendModelClass}
      * @param {object} response - Response payload.
      * @returns {{abilities: Record<string, boolean>, attributes: Record<string, FrontendModelAttributeValue>, associationCounts: Record<string, number>, queryData: Record<string, FrontendModelAttributeValue>, preloadedRelationships: Record<string, FrontendModelAttributeValue>, selectedAttributes: Set<string>}} - Attributes, preloaded relationships, association counts, queryData, abilities, and the selected-attributes set.
      */
-    static modelDataFromResponse(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, response: object): {
+    static modelDataFromResponse(this: FrontendModelClass, response: object): {
         abilities: Record<string, boolean>;
         attributes: Record<string, FrontendModelAttributeValue>;
         associationCounts: Record<string, number>;
@@ -579,26 +989,26 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Runs apply preloaded relationships.
      * @this {FrontendModelClass}
      * @param {FrontendModelBase} model - Model instance.
-     * @param {Record<string, ?>} preloadedRelationships - Preloaded relationship payload.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} preloadedRelationships - Preloaded relationship payload.
      * @returns {void}
      */
-    static applyPreloadedRelationships(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, model: FrontendModelBase, preloadedRelationships: Record<string, unknown>): void;
+    static applyPreloadedRelationships(this: FrontendModelClass, model: FrontendModelBase, preloadedRelationships: Record<string, ReturnType<typeof JSON.parse>>): void;
     /**
      * Runs instantiate relationship value.
      * @this {FrontendModelClass}
-     * @param {?} relationshipPayload - Relationship payload value.
+     * @param {ReturnType<typeof JSON.parse>} relationshipPayload - Relationship payload value.
      * @param {FrontendModelClass | null} targetModelClass - Target model class.
-     * @returns {?} - Instantiated relationship value.
+     * @returns {ReturnType<typeof JSON.parse>} - Instantiated relationship value.
      */
-    static instantiateRelationshipValue(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, relationshipPayload: unknown, targetModelClass: FrontendModelClass | null): unknown;
+    static instantiateRelationshipValue(this: FrontendModelClass, relationshipPayload: ReturnType<typeof JSON.parse>, targetModelClass: FrontendModelClass | null): ReturnType<typeof JSON.parse>;
     /**
      * Runs instantiate from response.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?> | InstanceType<T>} response - Response payload, or an already-hydrated instance of this class.
+     * @param {Record<string, ReturnType<typeof JSON.parse>> | InstanceType<T>} response - Response payload, or an already-hydrated instance of this class.
      * @returns {InstanceType<T>} - New model instance, or the same instance unchanged if it was already hydrated.
      */
-    static instantiateFromResponse<T extends FrontendModelClass>(this: T, response: Record<string, unknown> | InstanceType<T>): InstanceType<T>;
+    static instantiateFromResponse<T extends FrontendModelClass>(this: T, response: Record<string, ReturnType<typeof JSON.parse>> | InstanceType<T>): InstanceType<T>;
     /**
      * Runs find.
      * @template {FrontendModelClass} T
@@ -611,18 +1021,18 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Runs find by.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} conditions - Attribute match conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T> | null>} - Found model or null.
      */
-    static findBy<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T> | null>;
+    static findBy<T extends FrontendModelClass>(this: T, conditions: Record<string, ReturnType<typeof JSON.parse>>): Promise<InstanceType<T> | null>;
     /**
      * Runs find by or fail.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} conditions - Attribute match conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T>>} - Found model.
      */
-    static findByOrFail<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
+    static findByOrFail<T extends FrontendModelClass>(this: T, conditions: Record<string, ReturnType<typeof JSON.parse>>): Promise<InstanceType<T>>;
     /**
      * Runs to array.
      * @template {FrontendModelClass} T
@@ -648,18 +1058,18 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Runs where.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} conditions - Root-model where conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Root-model where conditions.
      * @returns {import("./query.js").default<T>} - Query with where conditions.
      */
-    static where<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): import("./query.js").default<T>;
+    static where<T extends FrontendModelClass>(this: T, conditions: Record<string, ReturnType<typeof JSON.parse>>): import("./query.js").default<T>;
     /**
      * Runs joins.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?> | Array<Record<string, ?>>} joins - Relationship descriptor joins.
+     * @param {Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>} joins - Relationship descriptor joins.
      * @returns {import("./query.js").default<T>} - Query with joins.
      */
-    static joins<T extends FrontendModelClass>(this: T, joins: Record<string, unknown> | Array<Record<string, unknown>>): import("./query.js").default<T>;
+    static joins<T extends FrontendModelClass>(this: T, joins: Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>): import("./query.js").default<T>;
     /**
      * Runs limit.
      * @template {FrontendModelClass} T
@@ -710,7 +1120,7 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {import("./query.js").FrontendModelEventOptions} [options] - Event query or record projection options.
      * @returns {Promise<() => void>} - Unsubscribe callback.
      */
-    static onCreate(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, callback: (payload: {
+    static onCreate(this: FrontendModelClass, callback: (payload: {
         id: string;
         model: FrontendModelBase;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
@@ -721,7 +1131,7 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {import("./query.js").FrontendModelEventOptions} [options] - Event query or record projection options.
      * @returns {Promise<() => void>} - Unsubscribe callback.
      */
-    static onUpdate(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, callback: (payload: {
+    static onUpdate(this: FrontendModelClass, callback: (payload: {
         id: string;
         model: FrontendModelBase;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
@@ -732,17 +1142,39 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {import("./query.js").FrontendModelEventOptions} [options] - Accepted for API symmetry; destroy events carry ids only.
      * @returns {Promise<() => void>} - Unsubscribe callback.
      */
-    static onDestroy(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, callback: (payload: {
+    static onDestroy(this: FrontendModelClass, callback: (payload: {
+        id: string;
+    }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
+    /**
+     * Instance-level hook fired when THIS record is updated. The
+     * instance's attributes are auto-merged with the broadcast payload
+     * before the callback runs, so callers can read fresh values via
+     * `this.someAttr()` without re-fetching.
+     * @param {(payload: {id: string, model: FrontendModelBase}) => void} callback - Event callback.
+     * @param {import("./query.js").FrontendModelEventOptions} [options] - Event query or record projection options.
+     * @returns {Promise<() => void>} - Unsubscribe callback.
+     */
+    onUpdate(callback: (payload: {
+        id: string;
+        model: FrontendModelBase;
+    }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
+    /**
+     * Instance-level hook fired when THIS record is destroyed.
+     * @param {(payload: {id: string}) => void} callback - Event callback.
+     * @param {import("./query.js").FrontendModelEventOptions} [options] - Accepted for API symmetry; destroy events carry ids only.
+     * @returns {Promise<() => void>} - Unsubscribe callback.
+     */
+    onDestroy(callback: (payload: {
         id: string;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
     /**
      * Runs pluck.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {...(string | string[] | Record<string, ?> | Array<Record<string, ?>>)} columns - Pluck definition(s).
-     * @returns {Promise<Array<?>>} - Plucked values.
+     * @param {...(string | string[] | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>)} columns - Pluck definition(s).
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - Plucked values.
      */
-    static pluck<T extends FrontendModelClass>(this: T, ...columns: (string | string[] | Record<string, unknown> | Array<Record<string, unknown>>)[]): Promise<Array<unknown>>;
+    static pluck<T extends FrontendModelClass>(this: T, ...columns: (string | string[] | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>)[]): Promise<Array<ReturnType<typeof JSON.parse>>>;
     /**
      * Runs search.
      * @template {FrontendModelClass} T
@@ -750,42 +1182,42 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {string[]} path - Relationship path.
      * @param {string} column - Column or attribute name.
      * @param {"eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq" | ">" | ">=" | "<" | "<="} operator - Search operator.
-     * @param {?} value - Search value.
+     * @param {ReturnType<typeof JSON.parse>} value - Search value.
      * @returns {FrontendModelQuery<T>} - Query builder with search filter.
      */
-    static search<T extends FrontendModelClass>(this: T, path: string[], column: string, operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq" | ">" | ">=" | "<" | "<=", value: unknown): FrontendModelQuery<T>;
+    static search<T extends FrontendModelClass>(this: T, path: string[], column: string, operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq" | ">" | ">=" | "<" | "<=", value: ReturnType<typeof JSON.parse>): FrontendModelQuery<T>;
     /**
      * Runs ransack.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} params - Ransack-style params hash.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Ransack-style params hash.
      * @returns {FrontendModelQuery<T>} - Query builder with Ransack filters applied.
      */
-    static ransack<T extends FrontendModelClass>(this: T, params: Record<string, unknown>): FrontendModelQuery<T>;
+    static ransack<T extends FrontendModelClass>(this: T, params: Record<string, ReturnType<typeof JSON.parse>>): FrontendModelQuery<T>;
     /**
      * Runs sort.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} sort - Sort definition(s).
+     * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>} sort - Sort definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with sort definitions.
      */
-    static sort<T extends FrontendModelClass>(this: T, sort: string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
+    static sort<T extends FrontendModelClass>(this: T, sort: string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>): FrontendModelQuery<T>;
     /**
      * Runs order.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} sort - Sort definition(s).
+     * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>} sort - Sort definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with sort definitions.
      */
-    static order<T extends FrontendModelClass>(this: T, sort: string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
+    static order<T extends FrontendModelClass>(this: T, sort: string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>): FrontendModelQuery<T>;
     /**
      * Runs group.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {string | string[] | Record<string, ?> | Array<Record<string, ?>>} group - Group definition(s).
+     * @param {string | string[] | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>} group - Group definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with group definitions.
      */
-    static group<T extends FrontendModelClass>(this: T, group: string | string[] | Record<string, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
+    static group<T extends FrontendModelClass>(this: T, group: string | string[] | Record<string, ReturnType<typeof JSON.parse>> | Array<Record<string, ReturnType<typeof JSON.parse>>>): FrontendModelQuery<T>;
     /**
      * Runs distinct.
      * @template {FrontendModelClass} T
@@ -843,19 +1275,19 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * Runs find or initialize by.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} conditions - Attribute match conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T>>} - Existing or initialized model.
      */
-    static findOrInitializeBy<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
+    static findOrInitializeBy<T extends FrontendModelClass>(this: T, conditions: Record<string, ReturnType<typeof JSON.parse>>): Promise<InstanceType<T>>;
     /**
      * Runs find or create by.
      * @template {FrontendModelClass} T
      * @this {T}
-     * @param {Record<string, ?>} conditions - Attribute match conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Attribute match conditions.
      * @param {(model: InstanceType<T>) => Promise<void> | void} [callback] - Optional callback before save when created.
      * @returns {Promise<InstanceType<T>>} - Existing or newly created model.
      */
-    static findOrCreateBy<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>, callback?: (model: InstanceType<T>) => Promise<void> | void): Promise<InstanceType<T>>;
+    static findOrCreateBy<T extends FrontendModelClass>(this: T, conditions: Record<string, ReturnType<typeof JSON.parse>>, callback?: (model: InstanceType<T>) => Promise<void> | void): Promise<InstanceType<T>>;
     /**
      * Runs create.
      * @template {FrontendModelClass} ModelClass
@@ -867,34 +1299,34 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
     /**
      * Runs assert find by conditions.
      * @this {FrontendModelClass}
-     * @param {Record<string, ?>} conditions - findBy conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - findBy conditions.
      * @returns {void}
      */
-    static assertFindByConditions(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, conditions: Record<string, unknown>): void;
+    static assertFindByConditions(this: FrontendModelClass, conditions: Record<string, ReturnType<typeof JSON.parse>>): void;
     /**
      * Runs matches find by conditions.
      * @this {FrontendModelClass}
      * @param {FrontendModelBase} model - Candidate model.
-     * @param {Record<string, ?>} conditions - Match conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} conditions - Match conditions.
      * @returns {boolean} - Whether the model matches all conditions.
      */
-    static matchesFindByConditions(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, model: FrontendModelBase, conditions: Record<string, unknown>): boolean;
+    static matchesFindByConditions(this: FrontendModelClass, model: FrontendModelBase, conditions: Record<string, ReturnType<typeof JSON.parse>>): boolean;
     /**
      * Runs find by condition value matches.
      * @this {FrontendModelClass}
-     * @param {?} actualValue - Actual model value.
-     * @param {?} expectedValue - Expected find condition value.
+     * @param {ReturnType<typeof JSON.parse>} actualValue - Actual model value.
+     * @param {ReturnType<typeof JSON.parse>} expectedValue - Expected find condition value.
      * @returns {boolean} - Whether values match.
      */
-    static findByConditionValueMatches(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, actualValue: unknown, expectedValue: unknown): boolean;
+    static findByConditionValueMatches(this: FrontendModelClass, actualValue: ReturnType<typeof JSON.parse>, expectedValue: ReturnType<typeof JSON.parse>): boolean;
     /**
      * Runs find by primitive values match.
      * @this {FrontendModelClass}
-     * @param {?} actualValue - Actual model value.
-     * @param {?} expectedValue - Expected find condition value.
+     * @param {ReturnType<typeof JSON.parse>} actualValue - Actual model value.
+     * @param {ReturnType<typeof JSON.parse>} expectedValue - Expected find condition value.
      * @returns {boolean} - Whether primitive values match after safe coercion.
      */
-    static findByPrimitiveValuesMatch(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, actualValue: unknown, expectedValue: unknown): boolean;
+    static findByPrimitiveValuesMatch(this: FrontendModelClass, actualValue: ReturnType<typeof JSON.parse>, expectedValue: ReturnType<typeof JSON.parse>): boolean;
     /**
      * Runs find by numeric string matches number.
      * @this {FrontendModelClass}
@@ -902,350 +1334,33 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      * @param {number} expectedNumber - Number value.
      * @returns {boolean} - Whether values represent the same number.
      */
-    static findByNumericStringMatchesNumber(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, numericString: string, expectedNumber: number): boolean;
+    static findByNumericStringMatchesNumber(this: FrontendModelClass, numericString: string, expectedNumber: number): boolean;
     /**
-     * Runs execute command.
-     * @this {FrontendModelClass}
-     * @param {FrontendModelCommandType} commandType - Command type.
-     * @param {Record<string, ?>} payload - Command payload.
-     * @returns {Promise<Record<string, ?>>} - Parsed JSON response.
+     * Runs update.
+     * @param {UpdateAttributes} [newAttributes] - New values to assign before update.
+     * @returns {Promise<this>} - Updated model.
      */
-    static executeCommand(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, commandType: FrontendModelCommandType, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    update(newAttributes?: UpdateAttributes): Promise<this>;
     /**
-     * Runs execute custom command.
-     * @this {FrontendModelClass}
-     * @param {object} args - Command arguments.
-     * @param {string} args.commandName - Raw command path segment.
-     * @param {FrontendModelRequestCommandType} args.commandType - Logical command type for error handling.
-     * @param {string | number | null} [args.memberId] - Optional member id for member-scoped commands.
-     * @param {Record<string, ?>} args.payload - Request payload.
-     * @param {string} args.resourcePath - Direct resource path.
-     * @returns {Promise<Record<string, FrontendModelAttributeValue>>} - Decoded response payload.
+     * Runs attach.
+     * @param {ReturnType<typeof JSON.parse>} attachmentInput - Attachment input or named attachment payload.
+     * @returns {Promise<void>} - Resolves when attached.
      */
-    static executeCustomCommand(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, { commandName, commandType, memberId, payload, resourcePath }: {
-        commandName: string;
-        commandType: FrontendModelRequestCommandType;
-        memberId?: string | number | null | undefined;
-        payload: Record<string, unknown>;
-        resourcePath: string;
-    }): Promise<Record<string, FrontendModelAttributeValue>>;
+    attach(attachmentInput: ReturnType<typeof JSON.parse>): Promise<void>;
     /**
-     * Runs throw on error frontend model response.
-     * @this {FrontendModelClass}
-     * @param {object} args - Arguments.
-     * @param {FrontendModelRequestCommandType} args.commandType - Command type.
-     * @param {Record<string, ?>} args.response - Decoded response.
-     * @returns {void}
+     * Runs save.
+     * @returns {Promise<this>} - Saved model.
      */
-    static throwOnErrorFrontendModelResponse(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>, { commandType, response }: {
-        commandType: FrontendModelRequestCommandType;
-        response: Record<string, unknown>;
-    }): void;
+    save(): Promise<this>;
     /**
-     * Runs configured frontend model attribute names.
-     * @this {FrontendModelClass}
-     * @returns {Set<string>} - Configured frontend model attribute names.
+     * Returns the subset of `_attributes` whose value has diverged from
+     * `_persistedAttributes`. Used by `save()` so the server receives only the
+     * fields the caller actually changed — avoiding strict permit rejections on
+     * framework-managed fields like `id`, `createdAt`, `updatedAt`, or owner
+     * foreign keys that the resource never lists in `permittedParams`.
+     * @returns {Record<string, FrontendModelAttributeValue>} - Changed attributes hash.
      */
-    static configuredFrontendModelAttributeNames(this: FrontendModelClass<FrontendModelBase<any, any, any>, any, any>): Set<string>;
-    /**
-     * Runs constructor.
-     * @param {Attributes | CreateAttributes} [attributes] - Initial attributes.
-     */
-    constructor(attributes?: Attributes | CreateAttributes);
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, FrontendModelAttributeValue>} */
-    _attributes: Record<string, FrontendModelAttributeValue>;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, FrontendModelHasManyRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>> | FrontendModelSingularRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>>>} */
-    _relationships: Record<string, FrontendModelHasManyRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>> | FrontendModelSingularRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>>>;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, FrontendModelAttachmentHandle>} */
-    _attachments: Record<string, FrontendModelAttachmentHandle>;
-    /**
-     * Rails-style nested attribute payloads queued for the next save.
-     * @type {Record<string, ?>}
-     */
-    _pendingNestedAttributes: Record<string, unknown>;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Set<string> | null} */
-    _selectedAttributes: Set<string> | null;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {boolean} */
-    _isNewRecord: boolean;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {boolean} */
-    _markedForDestruction: boolean;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, FrontendModelAttributeValue>} */
-    _persistedAttributes: Record<string, FrontendModelAttributeValue>;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Array<FrontendModelBase> | undefined} - Shared reference to sibling records loaded in the same batch. Used by auto-batch-preload.
-     */
-    _loadCohort: Array<FrontendModelBase> | undefined;
-    /**
-     * Runs attributes.
-     * @returns {Attributes} - Attributes hash.
-     */
-    attributes(): Attributes;
-    /**
-     * Runs is new record.
-     * @returns {boolean} - Whether this model has not yet been persisted.
-     */
-    isNewRecord(): boolean;
-    /**
-     * Runs is persisted.
-     * @returns {boolean} - Whether this model has been persisted.
-     */
-    isPersisted(): boolean;
-    /**
-     * Runs set is new record.
-     * @param {boolean} newIsNewRecord - New persisted-state flag.
-     * @returns {void}
-     */
-    setIsNewRecord(newIsNewRecord: boolean): void;
-    /**
-     * Marks this record for destruction when its parent is next saved through
-     * nested-attribute support. The record is not removed from the parent's
-     * relationship collection until the server confirms the delete.
-     * @returns {void} - No return value.
-     */
-    markForDestruction(): void;
-    /**
-     * Runs marked for destruction.
-     * @returns {boolean} - Whether this record is queued for nested destruction on next parent save.
-     */
-    markedForDestruction(): boolean;
-    /**
-     * Runs changes.
-     * @returns {Record<string, Array<?>>} - Changed attributes as `[oldValue, newValue]`.
-     */
-    changes(): Record<string, Array<unknown>>;
-    /**
-     * Runs is changed.
-     * @returns {boolean} - Whether any tracked attribute has changed.
-     */
-    isChanged(): boolean;
-    /**
-     * Runs get relationship by name.
-     * @param {string} relationshipName - Relationship name.
-     * @returns {FrontendModelRelationship} - Relationship state object.
-     */
-    getRelationshipByName(relationshipName: string): FrontendModelRelationship;
-    /**
-     * Runs get attachment by name.
-     * @param {string} attachmentName - Attachment name.
-     * @returns {FrontendModelAttachmentHandle} - Attachment helper.
-     */
-    getAttachmentByName(attachmentName: string): FrontendModelAttachmentHandle;
-    /**
-     * Runs load relationship.
-     * @param {string} relationshipName - Relationship name.
-     * @returns {Promise<FrontendModelBase | Array<FrontendModelBase> | null>} - Loaded relationship value.
-     */
-    loadRelationship(relationshipName: string): Promise<FrontendModelBase | Array<FrontendModelBase> | null>;
-    /**
-     * Preloads relationship(s) onto this already-loaded record. Accepts either a
-     * query built via `Model.preload(...).select(...)` or a raw preload spec
-     * (string / array / nested object). Relationships already preloaded with the
-     * required columns present are left untouched unless `force` is set. Carries
-     * the query's preload graph, select, selectsExtra, withCount, abilities, and
-     * queryData when re-fetching.
-     * @param {import("./query.js").default<FrontendModelClass> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} queryOrSpec - Preload source.
-     * @param {{force?: boolean}} [options] - Options.
-     * @returns {Promise<void>} - Resolves when preloading completes.
-     */
-    preload(queryOrSpec: import("./query.js").default<FrontendModelClass> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>, options?: {
-        force?: boolean;
-    }): Promise<void>;
-    /**
-     * Runs relationship or load.
-     * @param {string} relationshipName - Relationship name.
-     * @returns {Promise<FrontendModelBase | Array<FrontendModelBase> | null>} - Loaded relationship value.
-     */
-    relationshipOrLoad(relationshipName: string): Promise<FrontendModelBase | Array<FrontendModelBase> | null>;
-    /**
-     * Attempts to batch-load `relationshipName` across cohort siblings via a
-     * single `preload([name]).where({pk: [ids]}).toArray()` request, then copies
-     * the preloaded relationship state onto each sibling. Returns true when a
-     * batch ran, false when autoload is off, there is no cohort, or no batch
-     * candidates remain. Siblings whose relationship state is already set
-     * (preloaded or locally manipulated via `build` / `setRelationship`) are
-     * skipped so their cached/edited value is preserved.
-     * @param {string} relationshipName - Relationship name.
-     * @returns {Promise<boolean>} - Whether a cohort batch preload ran.
-     */
-    _tryCohortPreload(relationshipName: string): Promise<boolean>;
-    /**
-     * Runs set relationship.
-     * @param {string} relationshipName - Relationship name.
-     * @param {FrontendModelBase | null | undefined} relationshipValue - Relationship value.
-     * @returns {FrontendModelBase | null | undefined} - Assigned relationship value.
-     */
-    setRelationship(relationshipName: string, relationshipValue: FrontendModelBase | null | undefined): FrontendModelBase | null | undefined;
-    /**
-     * Runs assign attributes.
-     * @param {Attributes | CreateAttributes | UpdateAttributes | Record<string, FrontendModelAttributeValue>} attributes - Attributes to assign.
-     * @returns {void} - No return value.
-     */
-    assignAttributes(attributes: Attributes | CreateAttributes | UpdateAttributes | Record<string, FrontendModelAttributeValue>): void;
-    /**
-     * Runs clear relationship cache.
-     * @returns {void} - Clears cached relationship state.
-     */
-    clearRelationshipCache(): void;
-    /**
-     * Runs primary key value.
-     * @returns {number | string} - Primary key value.
-     */
-    primaryKeyValue(): number | string;
-    /**
-     * Runs read attribute.
-     * @param {string} attributeName - Attribute name.
-     * @returns {?} - Attribute value.
-     */
-    readAttribute(attributeName: string): unknown;
-    /**
-     * Whether an attribute value is currently loaded on this record. Used by the
-     * preloader to decide whether a relationship can be skipped because the
-     * requested columns are already present.
-     * @param {string} attributeName - Attribute name.
-     * @returns {boolean} - Whether the attribute is loaded.
-     */
-    hasLoadedAttribute(attributeName: string): boolean;
-    /**
-     * Read an association count attached by `.withCount(...)`. Counts
-     * live on a dedicated map separate from the record's attributes so
-     * a virtual count like `tasksCount` can't silently shadow a real
-     * column of the same name. Returns the attached value, or 0 when
-     * `.withCount(...)` wasn't requested for this attribute.
-     * @param {string} attributeName - Attribute name, e.g. `"tasksCount"` or a custom name from `.withCount({customName: {...}})`.
-     * @returns {number} - Attached association count, or zero when absent.
-     */
-    readCount(attributeName: string): number;
-    /**
-     * Internal setter called by `instantiateFromResponse` when hydrating
-     * association counts that rode along with the record payload.
-     * @param {string} attributeName - Attribute name.
-     * @param {number} value - Count value.
-     * @returns {void}
-     */
-    _setAssociationCount(attributeName: string, value: number): void;
-    /**
-     * Read a per-record ability result attached by `.abilities(...)`. The
-     * backend evaluates each requested action against the current
-     * ability for this record instance and ships the result alongside
-     * the record's attributes. Returns `false` when the action wasn't
-     * requested (or the ability denied it), so UI code can safely branch
-     * on `record.can("update")` without first checking whether the
-     * ability was loaded.
-     * @param {string} action - Ability action name, e.g. `"update"`.
-     * @returns {boolean} - Whether the requested ability is allowed.
-     */
-    can(action: string): boolean;
-    /**
-     * Internal setter called by `instantiateFromResponse` when hydrating
-     * per-record ability results that rode along with the record
-     * payload.
-     * @param {string} action - Ability action name.
-     * @param {boolean} value - Whether the current ability permits the action on this record.
-     * @returns {void}
-     */
-    _setComputedAbility(action: string, value: boolean): void;
-    /**
-     * Read a consumer-defined value attached by `.queryData(...)`. Stored
-     * on a dedicated map rather than `_attributes`, so a virtual alias
-     * like `tasksCount` cannot silently shadow a real column of the same
-     * name. Returns `null` when no registered fn produced that alias for
-     * this record (e.g. no child rows matched the aggregate).
-     * @param {string} name - queryData alias name.
-     * @returns {?} - Attached query-data value.
-     */
-    queryData(name: string): unknown;
-    /**
-     * Internal setter used by `instantiateFromResponse` when hydrating
-     * queryData values that rode along with the record payload.
-     * @param {string} name - queryData alias name.
-     * @param {?} value - Attached value.
-     * @returns {void}
-     */
-    _setQueryData(name: string, value: unknown): void;
-    /**
-     * Runs set attribute.
-     * @param {string} attributeName - Attribute name.
-     * @param {?} newValue - New value.
-     * @returns {?} - Assigned value.
-     */
-    setAttribute(attributeName: string, newValue: unknown): unknown;
-    /**
-     * Invalidates any cached belongsTo relationship whose foreign key matches the
-     * changed attribute. HasMany / hasOne relationships are left untouched because
-     * their foreign key lives on the child, not on this model, and blanket-clearing
-     * them would destroy nested-save state and preloaded children the caller never
-     * asked to invalidate.
-     *
-     * Foreign keys are inferred when not declared: for belongsTo `projectId` is
-     * inferred from relationship name `project`. Explicit `foreignKey` on the
-     * relationship definition takes precedence.
-     * @param {string} attributeName - Attribute name that changed.
-     * @returns {void}
-     */
-    _invalidateRelationshipsForAttribute(attributeName: string): void;
-    /**
-     * Instance-level hook fired when THIS record is updated. The
-     * instance's attributes are auto-merged with the broadcast payload
-     * before the callback runs, so callers can read fresh values via
-     * `this.someAttr()` without re-fetching.
-     * @param {(payload: {id: string, model: FrontendModelBase}) => void} callback - Event callback.
-     * @param {import("./query.js").FrontendModelEventOptions} [options] - Event query or record projection options.
-     * @returns {Promise<() => void>} - Unsubscribe callback.
-     */
-    onUpdate(callback: (payload: {
-        id: string;
-        model: FrontendModelBase;
-    }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
-    /**
-     * Instance-level hook fired when THIS record is destroyed.
-     * @param {(payload: {id: string}) => void} callback - Event callback.
-     * @param {import("./query.js").FrontendModelEventOptions} [options] - Accepted for API symmetry; destroy events carry ids only.
-     * @returns {Promise<() => void>} - Unsubscribe callback.
-     */
-    onDestroy(callback: (payload: {
-        id: string;
-    }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
-    /**
-     * Runs update.
-     * @param {UpdateAttributes} [newAttributes] - New values to assign before update.
-     * @returns {Promise<this>} - Updated model.
-     */
-    update(newAttributes?: UpdateAttributes): Promise<this>;
-    /**
-     * Runs attach.
-     * @param {?} attachmentInput - Attachment input or named attachment payload.
-     * @returns {Promise<void>} - Resolves when attached.
-     */
-    attach(attachmentInput: unknown): Promise<void>;
-    /**
-     * Runs save.
-     * @returns {Promise<this>} - Saved model.
-     */
-    save(): Promise<this>;
-    /**
-     * Returns the subset of `_attributes` whose value has diverged from
-     * `_persistedAttributes`. Used by `save()` so the server receives only the
-     * fields the caller actually changed — avoiding strict permit rejections on
-     * framework-managed fields like `id`, `createdAt`, `updatedAt`, or owner
-     * foreign keys that the resource never lists in `permittedParams`.
-     * @returns {Record<string, FrontendModelAttributeValue>} - Changed attributes hash.
-     */
-    _changedAttributesForSave(): Record<string, FrontendModelAttributeValue>;
+    _changedAttributesForSave(): Record<string, FrontendModelAttributeValue>;
     /**
      * Marks the current value for an attribute as already persisted so the next
      * save does not send it unless the caller changes it again.
@@ -1260,9 +1375,9 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
     destroy(): Promise<void>;
     /**
      * Builds the attachment payload queued on this model for the next save.
-     * @returns {Promise<Record<string, ?>>} Attachment payload keyed by attachment name.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Attachment payload keyed by attachment name.
      */
-    _buildAttachmentsPayload(): Promise<Record<string, unknown>>;
+    _buildAttachmentsPayload(): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /** Clears queued attachment inputs after a successful save. */
     _clearPendingAttachments(): void;
     /**
@@ -1277,57 +1392,94 @@ export default class FrontendModelBase<Attributes extends object = any, CreateAt
      *
      * Loaded but untouched records are omitted so nested save preserves Rails-style
      * "children not referenced in payload are left alone" semantics.
-     * @returns {Promise<Record<string, Array<Record<string, ?>>>>} - Per-relationship list of nested-attribute entries.
+     * @returns {Promise<Record<string, Array<Record<string, ReturnType<typeof JSON.parse>>>>>} - Per-relationship list of nested-attribute entries.
      */
-    _buildNestedAttributesPayload(): Promise<Record<string, Array<Record<string, unknown>>>>;
+    _buildNestedAttributesPayload(): Promise<Record<string, Array<Record<string, ReturnType<typeof JSON.parse>>>>>;
     /**
      * Builds the payload entry for this child when walked by a parent's
      * `_buildNestedAttributesPayload`. Returns `null` when the child has no
      * dirty state and no dirty descendants, so the parent can omit it.
-     * @returns {Promise<Record<string, ?> | null>} - Nested-attribute entry or null if clean.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Nested-attribute entry or null if clean.
      */
-    _nestedAttributesEntryForParentSave(): Promise<Record<string, unknown> | null>;
+    _nestedAttributesEntryForParentSave(): Promise<Record<string, ReturnType<typeof JSON.parse>> | null>;
     /**
      * Builds nested entries from a Rails-style submitted `*Attributes` value.
      * @param {FrontendModelClass} ModelClass - Parent model class.
      * @param {string} relationshipName - Nested relationship name.
-     * @param {?} value - Submitted nested attributes value.
-     * @returns {Promise<Array<Record<string, ?>>>} Nested entries for the transport payload.
+     * @param {ReturnType<typeof JSON.parse>} value - Submitted nested attributes value.
+     * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} Nested entries for the transport payload.
      */
-    _nestedAttributesPayloadForSubmittedValue(ModelClass: FrontendModelClass, relationshipName: string, value: unknown): Promise<Array<Record<string, unknown>>>;
+    _nestedAttributesPayloadForSubmittedValue(ModelClass: FrontendModelClass, relationshipName: string, value: ReturnType<typeof JSON.parse>): Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>;
     /**
      * Converts one submitted Rails-style nested attributes object into transport payload shape.
      * @param {FrontendModelClass} ModelClass - Nested child model class.
-     * @param {?} submittedEntry - Submitted nested attributes entry.
-     * @returns {Promise<Record<string, ?>>} Transport nested-attributes entry.
+     * @param {ReturnType<typeof JSON.parse>} submittedEntry - Submitted nested attributes entry.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Transport nested-attributes entry.
      */
-    _nestedAttributesEntryPayloadForSubmittedValue(ModelClass: FrontendModelClass, submittedEntry: unknown): Promise<Record<string, unknown>>;
+    _nestedAttributesEntryPayloadForSubmittedValue(ModelClass: FrontendModelClass, submittedEntry: ReturnType<typeof JSON.parse>): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Normalizes a submitted attachment value for transport.
      * @param {FrontendModelClass} ModelClass - Model class owning the attachment.
      * @param {string} attachmentName - Attachment name.
-     * @param {?} value - Submitted attachment value.
-     * @returns {Promise<Record<string, ?> | Record<string, ?>[]>} Normalized attachment payload.
+     * @param {ReturnType<typeof JSON.parse>} value - Submitted attachment value.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | Record<string, ReturnType<typeof JSON.parse>>[]>} Normalized attachment payload.
      */
-    _attachmentPayloadForSubmittedValue(ModelClass: FrontendModelClass, attachmentName: string, value: unknown): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    _attachmentPayloadForSubmittedValue(ModelClass: FrontendModelClass, attachmentName: string, value: ReturnType<typeof JSON.parse>): Promise<Record<string, ReturnType<typeof JSON.parse>> | Record<string, ReturnType<typeof JSON.parse>>[]>;
     /**
      * After a parent save with `nestedAttributes`, the server response includes
      * preloaded versions of the affected relationships. This replaces the local
      * `_loadedValue` for each nested-writable relationship with the server's
      * authoritative set, so destroyed children are dropped and newly-created
      * children get their server-assigned ids + persisted state.
-     * @param {Record<string, ?>} response - Command response payload.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} response - Command response payload.
      * @returns {void}
      */
-    _reconcileNestedAttributesFromResponse(response: Record<string, unknown>): void;
+    _reconcileNestedAttributesFromResponse(response: Record<string, ReturnType<typeof JSON.parse>>): void;
+    /**
+     * Runs execute command.
+     * @this {FrontendModelClass}
+     * @param {FrontendModelCommandType} commandType - Command type.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} payload - Command payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Parsed JSON response.
+     */
+    static executeCommand(this: FrontendModelClass, commandType: FrontendModelCommandType, payload: Record<string, ReturnType<typeof JSON.parse>>): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
+    /**
+     * Runs execute custom command.
+     * @this {FrontendModelClass}
+     * @param {{commandName: string, commandType: FrontendModelRequestCommandType, memberId?: string | number | null, payload: Record<string, ReturnType<typeof JSON.parse>>, resourcePath: string}} args - Command arguments.
+     * @returns {Promise<Record<string, FrontendModelAttributeValue>>} - Decoded response payload.
+     */
+    static executeCustomCommand(this: FrontendModelClass, args: {
+        commandName: string;
+        commandType: FrontendModelRequestCommandType;
+        memberId?: string | number | null;
+        payload: Record<string, ReturnType<typeof JSON.parse>>;
+        resourcePath: string;
+    }): Promise<Record<string, FrontendModelAttributeValue>>;
+    /**
+     * Runs throw on error frontend model response.
+     * @this {FrontendModelClass}
+     * @param {{commandType: FrontendModelRequestCommandType, response: Record<string, ReturnType<typeof JSON.parse>>}} args - Arguments.
+     * @returns {void}
+     */
+    static throwOnErrorFrontendModelResponse(this: FrontendModelClass, args: {
+        commandType: FrontendModelRequestCommandType;
+        response: Record<string, ReturnType<typeof JSON.parse>>;
+    }): void;
+    /**
+     * Runs configured frontend model attribute names.
+     * @this {FrontendModelClass}
+     * @returns {Set<string>} - Configured frontend model attribute names.
+     */
+    static configuredFrontendModelAttributeNames(this: FrontendModelClass): Set<string>;
 }
 /** Public frontend model for safe Velocious attachment metadata. */
-export class VelociousAttachment extends FrontendModelBase<any, any, any> {
+export declare class VelociousAttachment extends FrontendModelBase {
     /**
-     * Runs constructor.
-     * @param {Attributes | CreateAttributes} [attributes] - Initial attributes.
+     * Runs resource config.
+     * @returns {FrontendModelResourceConfig} - Resource config.
      */
-    constructor(attributes?: any);
+    static resourceConfig(): FrontendModelResourceConfig;
     /**
      * Returns the attachment id.
      * @returns {string} - Attachment id.
@@ -1379,250 +1531,4 @@ export class VelociousAttachment extends FrontendModelBase<any, any, any> {
      */
     updatedAt(): Date;
 }
-/**
- * Frontend model relationship helper type. Returned by `getRelationshipByName`,
- * which generated models immediately cast to their concrete relationship type
- * (e.g. `FrontendModelSingularRelationship<Owner, Target, TargetCreateAttributes>`).
- * The members use `any` type args so that cast is allowed regardless of the
- * target model's typed-attribute generics — a concrete `FrontendModelBase` member
- * here makes the cast a non-overlapping (TS2352) error for every typed model.
- */
-export type FrontendModelRelationship = FrontendModelHasManyRelationship<any, any, any> | FrontendModelSingularRelationship<any, any, any>;
-/**
- * Defines this typedef.
- */
-export type FrontendModelModelEventCallbackEntry = {
-    callback: (payload: {
-        id: string;
-        model: FrontendModelBase;
-    }) => void;
-    eventFilterKey: string | null;
-    eventFilterPayload: import("./query.js").FrontendModelEventFilterPayload | null;
-    projectionPayload: import("./query.js").FrontendModelProjectionPayload;
-};
-/**
- * Defines this typedef.
- */
-export type FrontendModelDestroyEventCallbackEntry = {
-    callback: (payload: {
-        id: string;
-    }) => void;
-};
-/**
- * FrontendModelCommandType type.
- */
-export type FrontendModelCommandType = "create" | "find" | "index" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url";
-/**
- * FrontendModelRequestCommandType type.
- */
-export type FrontendModelRequestCommandType = FrontendModelCommandType | string;
-/**
- * Model-like instance value supported by frontend-model transport.
- */
-export type FrontendModelTransportModelValue = {
-    attributes: () => Record<string, unknown>;
-};
-/**
- * Special scalar values restored by frontend-model transport.
- */
-export type FrontendModelTransportScalarValue = undefined | null | boolean | number | string | bigint | Date | FrontendModelTransportModelValue;
-/**
- * Plain object supported by frontend-model transport values.
- * Nested values are intentionally opaque because TypeScript rejects recursive
- * JSDoc typedefs for this transport value contract.
- */
-export type FrontendModelTransportObject = Record<string, unknown>;
-/**
- * Value supported by frontend-model transport serialization and deserialization.
- */
-export type FrontendModelTransportValue = FrontendModelTransportScalarValue | FrontendModelTransportObject | Array<unknown>;
-/**
- * Frontend model attribute value used when generated metadata cannot infer a narrower type.
- */
-export type FrontendModelAttributeValue = FrontendModelTransportValue;
-/**
- * Defines this typedef.
- */
-export type FrontendModelAttachmentDefinition = {
-    type: "hasOne" | "hasMany";
-};
-/**
- * Defines frontend-model attribute metadata.
- */
-export type FrontendModelAttributeDefinition = {
-    columnType?: string;
-    dataType?: string;
-    jsDocType?: string;
-    name?: string;
-    null?: boolean;
-    selectedByDefault?: boolean;
-    sqlType?: string;
-    type?: string;
-};
-/**
- * Attachment input accepted by frontend-model attachment helpers before normalization.
- */
-export type FrontendModelAttachmentInput = Record<string, unknown> | {
-    arrayBuffer: () => Promise<ArrayBuffer>;
-    type?: string;
-    name?: string;
-} | null | undefined;
-/**
- * Defines this typedef.
- */
-export type FrontendModelSyncMetadata = Record<string, FrontendModelTransportValue>;
-/**
- * Defines this typedef.
- */
-export type FrontendModelSyncConflictStrategy = "optimisticVersion" | "serverWins" | "lastWriterWins" | "fieldThreeWay" | "appendOnly";
-/**
- * Defines this typedef.
- */
-export type FrontendModelSyncConfig = {
-    enabled: boolean;
-    operations: string[];
-    policyHash: string;
-    policyVersion: string | null;
-    conflictStrategy?: FrontendModelSyncConflictStrategy;
-    metadata?: FrontendModelSyncMetadata;
-};
-/**
- * Defines this typedef.
- */
-export type FrontendModelResourceConfig = {
-    attributes?: Array<string | FrontendModelAttributeDefinition> | Record<string, FrontendModelAttributeDefinition>;
-    builtInCollectionCommands?: string[];
-    builtInMemberCommands?: string[];
-    collectionCommands?: string[];
-    commands?: string[];
-    memberCommands?: string[];
-    attachments?: Record<string, FrontendModelAttachmentDefinition>;
-    modelName?: string;
-    nestedAttributes?: Record<string, {
-        allowDestroy?: boolean;
-        limit?: number;
-    }>;
-    primaryKey?: string;
-    relationships?: string[];
-    sync?: FrontendModelSyncConfig;
-};
-/**
- * Frontend model constructor type.
- */
-export type FrontendModelConstructor<T extends FrontendModelBase = FrontendModelBase<any, any, any>> = {
-    new (attributes?: Record<string, FrontendModelAttributeValue>): T;
-};
-/**
- * Frontend model static side.
- *
- * The template defaults are intentionally permissive (`any` model/attribute
- * params). The bare `FrontendModelClass` is the `@this`/constraint type on the
- * static query methods (findBy/find/where/preload/...); a generated subclass
- * declares typed-attribute generics (e.g. `FrontendModelBase<AccountAttributes,
- * AccountCreateAttributes, AccountUpdateAttributes>`) which, against a concrete
- * `Record<string, FrontendModelTransportValue>` default, fail the constraint by
- * invariance. Defaulting to `any` lets any subclass satisfy the constraint while
- * the methods' own `@template T` still captures the precise calling class for
- * their return types.
- */
-export type FrontendModelClass<T extends FrontendModelBase = FrontendModelBase<any, any, any>, Attributes extends object = any, CreateAttributes extends object = any> = {
-    new (): T;
-    create(attributes?: CreateAttributes): Promise<T>;
-} & Omit<typeof FrontendModelBase, "create" | "prototype">;
-/**
- * Create attributes accepted by a frontend model instance.
- */
-export type FrontendModelCreateAttributesFor<T extends FrontendModelBase> = T extends FrontendModelBase<Record<string, FrontendModelAttributeValue>, infer CreateAttributes, infer _UpdateAttributes> ? CreateAttributes : Record<string, FrontendModelAttributeValue>;
-/**
- * Loaded instance type for relationship helper generics. Older generated
- * frontend models passed model classes into relationship helpers, while newer
- * generated models pass instance types.
- */
-export type FrontendModelRelationshipModel<T extends FrontendModelBase<any, any, any> | typeof FrontendModelBase> = T extends typeof FrontendModelBase ? InstanceType<T> : T;
-/**
- * FrontendModelTransportConfig type.
- */
-export type FrontendModelTransportConfig = {
-    /**
-     * - Optional frontend-model URL. This should be the shared endpoint (for example `"/frontend-models"` or `"https://example.com/frontend-models"`).
-     */
-    url?: string | (() => string | undefined | null) | undefined;
-    /**
-     * - Deprecated shared-endpoint flag retained for compatibility. Frontend-model CRUD/custom commands use the shared frontend-model API envelope by default.
-     */
-    shared?: boolean | undefined;
-    /**
-     * - Optional websocket URL. When set, Velocious creates and manages its own websocket client internally. Subscriptions use the websocket; CRUD uses HTTP and falls back gracefully. Example: `"ws://localhost:3006/websocket"`.
-     */
-    websocketUrl?: string | (() => string | undefined | null) | undefined;
-    /**
-     * - Optional websocket client for shared frontend-model API requests and subscriptions. Its `post` receives the bounded-deadline `signal` and should forward it into the underlying transport so the deadline can abort the live request and its response-body read.
-     */
-    websocketClient?: {
-        post: (path: string, body?: unknown, options?: {
-            headers?: Record<string, string>;
-            signal?: AbortSignal;
-        }) => Promise<{
-            json: () => unknown;
-        }>;
-        subscribe: (channel: string, options: {
-            params?: Record<string, unknown>;
-        }, callback: (payload: unknown) => void) => (() => void);
-        subscribeAndWait?: (channel: string, options: {
-            params?: Record<string, unknown>;
-        }, callback: (payload: unknown) => void) => Promise<(() => void)>;
-    } | undefined;
-    /**
-     * - Extra HTTP/WS headers to attach to every frontend-model API request. Pass a function to compute them at request time (for example to include the current locale).
-     */
-    requestHeaders?: Record<string, string> | (() => Record<string, string>) | undefined;
-    /**
-     * - Bounded deadline in milliseconds covering connection, response headers, and response-body consumption for each frontend-model API request. On expiry the live fetch/adapter request is aborted (built on awaitery's `timeout`) and awaitery's `TimeoutError` is thrown, so callers can classify a timeout via `error instanceof TimeoutError`. Pass a function to resolve it per request. Falsy/absent means no deadline.
-     */
-    timeout?: number | (() => number | undefined | null) | undefined;
-    /**
-     * - Optional caller/session AbortSignal composed with the deadline. Aborting it cancels the live request (for example on session shutdown or offline transition); the resulting abort error stays distinguishable from a timeout. Pass a function to resolve the current signal per request.
-     */
-    signal?: AbortSignal | (() => AbortSignal | undefined | null) | undefined;
-    /**
-     * - Optional sessionId persistence hook forwarded to the internal `VelociousWebsocketClient` so WS sessions can be resumed across page reloads / app restarts.
-     */
-    sessionStore?: {
-        get: () => string | null | undefined | Promise<string | null | undefined>;
-        set: (sessionId: string) => void | Promise<void>;
-        clear: () => void | Promise<void>;
-    } | undefined;
-    /**
-     * - IANA timezone sent with every frontend-model API request for timezone-less datetime parsing.
-     */
-    timeZone?: string | (() => string | null | undefined) | undefined;
-    /**
-     * - Offline mutation queue configuration.
-     */
-    offlineSync?: {
-        actorDeviceId: string;
-        actorUserId: string;
-        clientMutationId?: () => string;
-        enabled?: boolean;
-        mutationLog: import("../sync/local-mutation-log.js").default;
-        now?: () => Date;
-        offlineGrant: {
-            id: string;
-        };
-    } | undefined;
-};
-/**
- * FrontendModelIdleWaitArgs type.
- */
-export type FrontendModelIdleWaitArgs = {
-    /**
-     * - Milliseconds the transport must stay idle before resolving.
-     */
-    quietMs?: number | undefined;
-    /**
-     * - Timeout in milliseconds.
-     */
-    timeout?: number | undefined;
-};
-import FrontendModelQuery from "./query.js";
 //# sourceMappingURL=base.d.ts.map