velocious 1.0.445 → 1.0.447

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

@@ -9,10 +9,10 @@ export class AttributeNotSelectedError extends Error {
 }
 /**
  * Lightweight singular relationship state holder for frontend model instances.
- * @template {typeof FrontendModelBase} S
- * @template {typeof FrontendModelBase} T
+ * @template {FrontendModelClass} S
+ * @template {FrontendModelClass} T
  */
-export class FrontendModelSingularRelationship<S extends typeof FrontendModelBase, T extends typeof FrontendModelBase> {
+export class FrontendModelSingularRelationship<S extends FrontendModelClass, T extends FrontendModelClass> {
     /**
      * Runs constructor.
      * @param {InstanceType<S>} model - Parent model.
@@ -50,10 +50,10 @@ export class FrontendModelSingularRelationship<S extends typeof FrontendModelBas
 }
 /**
  * Lightweight has-many relationship state holder for frontend model instances.
- * @template {typeof FrontendModelBase} S
- * @template {typeof FrontendModelBase} T
+ * @template {FrontendModelClass} S
+ * @template {FrontendModelClass} T
  */
-export class FrontendModelHasManyRelationship<S extends typeof FrontendModelBase, T extends typeof FrontendModelBase> {
+export class FrontendModelHasManyRelationship<S extends FrontendModelClass, T extends FrontendModelClass> {
     /**
      * Runs constructor.
      * @param {InstanceType<S>} model - Parent model.
@@ -185,8 +185,31 @@ export class FrontendModelAttachmentHandle {
         model: FrontendModelBase;
         attachmentName: string;
     });
+    /**
+     * Pending attachment inputs queued for the next model save.
+     * @type {FrontendModelAttachmentInput[]}
+     */
+    pendingInputs: FrontendModelAttachmentInput[];
     model: FrontendModelBase;
     attachmentName: string;
+    /**
+     * Queue attachment input for the parent model's next save.
+     * @param {FrontendModelAttachmentInput | FrontendModelAttachmentInput[]} input - Attachment input.
+     * @returns {void}
+     */
+    queueAttach(input: FrontendModelAttachmentInput | FrontendModelAttachmentInput[]): void;
+    /**
+     * Whether this attachment has queued inputs for the next model save.
+     * @returns {boolean} Whether any pending inputs exist.
+     */
+    hasPendingAttachments(): boolean;
+    /**
+     * Builds the save payload for queued attachment inputs.
+     * @returns {Promise<Record<string, ?> | Record<string, ?>[] | undefined>} Normalized attachment payload.
+     */
+    pendingAttachmentsPayload(): Promise<Record<string, unknown> | Record<string, unknown>[] | undefined>;
+    /** Clears queued attachment inputs after a successful model save. */
+    clearPendingAttachments(): void;
     /**
      * Runs attach.
      * @param {?} input - Attachment input.
@@ -235,10 +258,10 @@ export default class FrontendModelBase {
     static setAutoload(newValue: boolean): void;
     /**
      * Runs ensure generated attachment methods.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {void} - Ensures attachment helper methods exist on the prototype.
      */
-    static ensureGeneratedAttachmentMethods(this: typeof FrontendModelBase): void;
+    static ensureGeneratedAttachmentMethods(this: FrontendModelClass): void;
     /**
      * Runs resource config.
      * @returns {FrontendModelResourceConfig} - Resource configuration.
@@ -246,103 +269,110 @@ export default class FrontendModelBase {
     static resourceConfig(): FrontendModelResourceConfig;
     /**
      * Runs relationship model classes.
-     * @this {typeof FrontendModelBase}
-     * @returns {Record<string, typeof FrontendModelBase | string>} - Relationship model classes (or class name strings) keyed by relationship name.
+     * @this {FrontendModelClass}
+     * @returns {Record<string, FrontendModelClass | string>} - Relationship model classes (or class name strings) keyed by relationship name.
      */
-    static relationshipModelClasses(this: typeof FrontendModelBase): Record<string, typeof FrontendModelBase | 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 {typeof FrontendModelBase} modelClass - Model class to register.
+     * @param {FrontendModelClass} modelClass - Model class to register.
      * @returns {void}
      */
-    static registerModel(modelClass: typeof FrontendModelBase): void;
+    static registerModel(modelClass: FrontendModelClass): void;
     /**
      * Runs define scope.
      * @param {(...args: Array<?>) => ?} callback - Scope callback.
-     * @returns {((...args: Array<?>) => import("./query.js").default<typeof FrontendModelBase>) & {scope: (...args: Array<?>) => import("../utils/model-scope.js").ModelScopeDescriptor}} - Scope helper.
+     * @returns {((...args: Array<?>) => import("./query.js").default<FrontendModelClass>) & {scope: (...args: Array<?>) => import("../utils/model-scope.js").ModelScopeDescriptor}} - Scope helper.
      */
-    static defineScope(callback: (...args: Array<unknown>) => unknown): ((...args: Array<unknown>) => import("./query.js").default<typeof FrontendModelBase>) & {
+    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;
     };
     /**
      * Resolve a relationship model class value that may be a class reference or a string name.
-     * @param {typeof FrontendModelBase | string | null | undefined} value - Class or class name.
-     * @returns {typeof FrontendModelBase | null} - Resolved model class.
+     * @param {FrontendModelClass | string | null | undefined} value - Class or class name.
+     * @returns {FrontendModelClass | null} - Resolved model class.
      */
-    static resolveModelClass(value: typeof FrontendModelBase | string | null | undefined): typeof FrontendModelBase | null;
+    static resolveModelClass(value: FrontendModelClass | string | null | undefined): FrontendModelClass | null;
     /**
      * Runs relationship definitions.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {Record<string, {type: "belongsTo" | "hasOne" | "hasMany", autoload?: boolean}>} - Relationship definitions keyed by relationship name.
      */
-    static relationshipDefinitions(this: typeof FrontendModelBase): Record<string, {
+    static relationshipDefinitions(this: FrontendModelClass): Record<string, {
         type: "belongsTo" | "hasOne" | "hasMany";
         autoload?: boolean;
     }>;
     /**
      * Runs attachment definitions.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {Record<string, FrontendModelAttachmentDefinition>} - Attachment definitions keyed by attachment name.
      */
-    static attachmentDefinitions(this: typeof FrontendModelBase): Record<string, FrontendModelAttachmentDefinition>;
+    static attachmentDefinitions(this: FrontendModelClass): Record<string, FrontendModelAttachmentDefinition>;
     /**
      * Runs attachment definition.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {string} attachmentName - Attachment name.
      * @returns {FrontendModelAttachmentDefinition | null} - Attachment definition.
      */
-    static attachmentDefinition(this: typeof FrontendModelBase, attachmentName: string): FrontendModelAttachmentDefinition | null;
+    static attachmentDefinition(this: FrontendModelClass, attachmentName: string): FrontendModelAttachmentDefinition | null;
     /**
      * Runs relationship definition.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {string} relationshipName - Relationship name.
      * @returns {{type: "belongsTo" | "hasOne" | "hasMany", autoload?: boolean} | null} - Relationship definition.
      */
-    static relationshipDefinition(this: typeof FrontendModelBase, relationshipName: string): {
+    static relationshipDefinition(this: FrontendModelClass, relationshipName: string): {
         type: "belongsTo" | "hasOne" | "hasMany";
         autoload?: boolean;
     } | null;
+    /**
+     * Resolves a Rails-style nested attributes key to a configured relationship.
+     * @this {FrontendModelClass}
+     * @param {string} attributeName - Candidate attribute name, such as `tasksAttributes`.
+     * @returns {string | null} Relationship name when nested attributes are configured.
+     */
+    static nestedAttributesRelationshipName(this: FrontendModelClass, attributeName: string): string | null;
     /**
      * Runs relationship model class.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {string} relationshipName - Relationship name.
-     * @returns {typeof FrontendModelBase | null} - Target relationship model class.
+     * @returns {FrontendModelClass | null} - Target relationship model class.
      */
-    static relationshipModelClass(this: typeof FrontendModelBase, relationshipName: string): typeof FrontendModelBase | null;
+    static relationshipModelClass(this: FrontendModelClass, relationshipName: string): FrontendModelClass | null;
     /**
      * Runs primary key.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {string} - Primary key name.
      */
-    static primaryKey(this: typeof FrontendModelBase): string;
+    static primaryKey(this: FrontendModelClass): string;
     /**
      * Runs resource path.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {string} - Derived resource path.
      */
-    static resourcePath(this: typeof FrontendModelBase): string;
+    static resourcePath(this: FrontendModelClass): string;
     /**
      * Runs command name.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {FrontendModelCommandType} commandType - Command type.
      * @returns {string} - Resolved command name.
      */
-    static commandName(this: typeof FrontendModelBase, commandType: FrontendModelCommandType): string;
+    static commandName(this: FrontendModelClass, commandType: FrontendModelCommandType): string;
     /**
      * Runs normalize custom command payload arguments.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {Array<?>} args - Command arguments.
      * @returns {Record<string, ?>} - Command payload.
      */
-    static normalizeCustomCommandPayloadArguments(this: typeof FrontendModelBase, args: Array<unknown>): Record<string, unknown>;
+    static normalizeCustomCommandPayloadArguments(this: FrontendModelClass, args: Array<unknown>): Record<string, unknown>;
     /**
      * Returns the model name, preferring an explicit `static modelName` declaration
      * over the JavaScript class `.name` property. This allows minified builds to
      * preserve correct model names without relying on `keep_classnames`.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {string} - The model name.
      */
-    static getModelName(this: typeof FrontendModelBase): string;
+    static getModelName(this: FrontendModelClass): string;
     /**
      * Runs configure transport.
      * @param {FrontendModelTransportConfig} config - Frontend model transport configuration.
@@ -452,18 +482,18 @@ export default class FrontendModelBase {
     static installWebsocketTestHooks(): void;
     /**
      * Runs attributes from response.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {object} response - Response payload.
      * @returns {Record<string, ?>} - Attributes from payload.
      */
-    static attributesFromResponse(this: typeof FrontendModelBase, response: object): Record<string, unknown>;
+    static attributesFromResponse(this: FrontendModelClass, response: object): Record<string, unknown>;
     /**
      * Runs model data from response.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {object} response - Response payload.
      * @returns {{abilities: Record<string, boolean>, attributes: Record<string, ?>, associationCounts: Record<string, number>, queryData: Record<string, ?>, preloadedRelationships: Record<string, ?>, selectedAttributes: Set<string>}} - Attributes, preloaded relationships, association counts, queryData, abilities, and the selected-attributes set.
      */
-    static modelDataFromResponse(this: typeof FrontendModelBase, response: object): {
+    static modelDataFromResponse(this: FrontendModelClass, response: object): {
         abilities: Record<string, boolean>;
         attributes: Record<string, unknown>;
         associationCounts: Record<string, number>;
@@ -473,175 +503,175 @@ export default class FrontendModelBase {
     };
     /**
      * Runs apply preloaded relationships.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {FrontendModelBase} model - Model instance.
      * @param {Record<string, ?>} preloadedRelationships - Preloaded relationship payload.
      * @returns {void}
      */
-    static applyPreloadedRelationships(this: typeof FrontendModelBase, model: FrontendModelBase, preloadedRelationships: Record<string, unknown>): void;
+    static applyPreloadedRelationships(this: FrontendModelClass, model: FrontendModelBase, preloadedRelationships: Record<string, unknown>): void;
     /**
      * Runs instantiate relationship value.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {?} relationshipPayload - Relationship payload value.
-     * @param {typeof FrontendModelBase | null} targetModelClass - Target model class.
+     * @param {FrontendModelClass | null} targetModelClass - Target model class.
      * @returns {?} - Instantiated relationship value.
      */
-    static instantiateRelationshipValue(this: typeof FrontendModelBase, relationshipPayload: unknown, targetModelClass: typeof FrontendModelBase | null): unknown;
+    static instantiateRelationshipValue(this: FrontendModelClass, relationshipPayload: unknown, targetModelClass: FrontendModelClass | null): unknown;
     /**
      * Runs instantiate from response.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?> | 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 typeof FrontendModelBase>(this: T, response: Record<string, unknown> | InstanceType<T>): InstanceType<T>;
+    static instantiateFromResponse<T extends FrontendModelClass>(this: T, response: Record<string, unknown> | InstanceType<T>): InstanceType<T>;
     /**
      * Runs find.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {number | string} id - Record identifier.
      * @returns {Promise<InstanceType<T>>} - Resolved model.
      */
-    static find<T extends typeof FrontendModelBase>(this: T, id: number | string): Promise<InstanceType<T>>;
+    static find<T extends FrontendModelClass>(this: T, id: number | string): Promise<InstanceType<T>>;
     /**
      * Runs find by.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T> | null>} - Found model or null.
      */
-    static findBy<T extends typeof FrontendModelBase>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T> | null>;
+    static findBy<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T> | null>;
     /**
      * Runs find by or fail.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T>>} - Found model.
      */
-    static findByOrFail<T extends typeof FrontendModelBase>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
+    static findByOrFail<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
     /**
      * Runs to array.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {Promise<InstanceType<T>[]>} - Loaded model instances.
      */
-    static toArray<T extends typeof FrontendModelBase>(this: T): Promise<InstanceType<T>[]>;
+    static toArray<T extends FrontendModelClass>(this: T): Promise<InstanceType<T>[]>;
     /**
      * Runs load.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {Promise<InstanceType<T>[]>} - Loaded model instances.
      */
-    static load<T extends typeof FrontendModelBase>(this: T): Promise<InstanceType<T>[]>;
+    static load<T extends FrontendModelClass>(this: T): Promise<InstanceType<T>[]>;
     /**
      * Runs all.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {FrontendModelQuery<T>} - Query builder.
      */
-    static all<T extends typeof FrontendModelBase>(this: T): FrontendModelQuery<T>;
+    static all<T extends FrontendModelClass>(this: T): FrontendModelQuery<T>;
     /**
      * Runs where.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} conditions - Root-model where conditions.
      * @returns {import("./query.js").default<T>} - Query with where conditions.
      */
-    static where<T extends typeof FrontendModelBase>(this: T, conditions: Record<string, unknown>): import("./query.js").default<T>;
+    static where<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): import("./query.js").default<T>;
     /**
      * Runs joins.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?> | Array<Record<string, ?>>} joins - Relationship descriptor joins.
      * @returns {import("./query.js").default<T>} - Query with joins.
      */
-    static joins<T extends typeof FrontendModelBase>(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, unknown> | Array<Record<string, unknown>>): import("./query.js").default<T>;
     /**
      * Runs limit.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {number} value - Maximum number of records.
      * @returns {import("./query.js").default<T>} - Query with limit.
      */
-    static limit<T extends typeof FrontendModelBase>(this: T, value: number): import("./query.js").default<T>;
+    static limit<T extends FrontendModelClass>(this: T, value: number): import("./query.js").default<T>;
     /**
      * Runs offset.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {number} value - Number of records to skip.
      * @returns {import("./query.js").default<T>} - Query with offset.
      */
-    static offset<T extends typeof FrontendModelBase>(this: T, value: number): import("./query.js").default<T>;
+    static offset<T extends FrontendModelClass>(this: T, value: number): import("./query.js").default<T>;
     /**
      * Runs page.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {number} pageNumber - 1-based page number.
      * @returns {import("./query.js").default<T>} - Query with page applied.
      */
-    static page<T extends typeof FrontendModelBase>(this: T, pageNumber: number): import("./query.js").default<T>;
+    static page<T extends FrontendModelClass>(this: T, pageNumber: number): import("./query.js").default<T>;
     /**
      * Runs per page.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {number} value - Number of records per page.
      * @returns {import("./query.js").default<T>} - Query with page size.
      */
-    static perPage<T extends typeof FrontendModelBase>(this: T, value: number): import("./query.js").default<T>;
+    static perPage<T extends FrontendModelClass>(this: T, value: number): import("./query.js").default<T>;
     /**
      * Runs count.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {Promise<number>} - Number of loaded model instances.
      */
-    static count<T extends typeof FrontendModelBase>(this: T): Promise<number>;
+    static count<T extends FrontendModelClass>(this: T): Promise<number>;
     /**
      * Class-level hook fired when any record of this model is created.
      * Subscribe-time authorization only — once a subscription is
      * accepted, future `create` events for this model are delivered
      * without re-checking per-record visibility. Query options can still
      * narrow which events reach this callback.
-     * @this {typeof FrontendModelBase}
-     * @param {(payload: {id: string, model: InstanceType<typeof FrontendModelBase>}) => void} callback - Event callback.
+     * @this {FrontendModelClass}
+     * @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.
      */
-    static onCreate(this: typeof FrontendModelBase, callback: (payload: {
+    static onCreate(this: FrontendModelClass, callback: (payload: {
         id: string;
-        model: InstanceType<typeof FrontendModelBase>;
+        model: FrontendModelBase;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
     /**
      * Class-level hook fired when any record of this model is updated.
-     * @this {typeof FrontendModelBase}
-     * @param {(payload: {id: string, model: InstanceType<typeof FrontendModelBase>}) => void} callback - Event callback.
+     * @this {FrontendModelClass}
+     * @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.
      */
-    static onUpdate(this: typeof FrontendModelBase, callback: (payload: {
+    static onUpdate(this: FrontendModelClass, callback: (payload: {
         id: string;
-        model: InstanceType<typeof FrontendModelBase>;
+        model: FrontendModelBase;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
     /**
      * Class-level hook fired when any record of this model is destroyed.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @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.
      */
-    static onDestroy(this: typeof FrontendModelBase, callback: (payload: {
+    static onDestroy(this: FrontendModelClass, callback: (payload: {
         id: string;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
     /**
      * Runs pluck.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {...(string | string[] | Record<string, ?> | Array<Record<string, ?>>)} columns - Pluck definition(s).
      * @returns {Promise<Array<?>>} - Plucked values.
      */
-    static pluck<T extends typeof FrontendModelBase>(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, unknown> | Array<Record<string, unknown>>)[]): Promise<Array<unknown>>;
     /**
      * Runs search.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {string[]} path - Relationship path.
      * @param {string} column - Column or attribute name.
@@ -649,167 +679,167 @@ export default class FrontendModelBase {
      * @param {?} value - Search value.
      * @returns {FrontendModelQuery<T>} - Query builder with search filter.
      */
-    static search<T extends typeof FrontendModelBase>(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: unknown): FrontendModelQuery<T>;
     /**
      * Runs ransack.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} params - Ransack-style params hash.
      * @returns {FrontendModelQuery<T>} - Query builder with Ransack filters applied.
      */
-    static ransack<T extends typeof FrontendModelBase>(this: T, params: Record<string, unknown>): FrontendModelQuery<T>;
+    static ransack<T extends FrontendModelClass>(this: T, params: Record<string, unknown>): FrontendModelQuery<T>;
     /**
      * Runs sort.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} sort - Sort definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with sort definitions.
      */
-    static sort<T extends typeof FrontendModelBase>(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, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
     /**
      * Runs order.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {string | string[] | string[][] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} sort - Sort definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with sort definitions.
      */
-    static order<T extends typeof FrontendModelBase>(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, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
     /**
      * Runs group.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {string | string[] | Record<string, ?> | Array<Record<string, ?>>} group - Group definition(s).
      * @returns {FrontendModelQuery<T>} - Query builder with group definitions.
      */
-    static group<T extends typeof FrontendModelBase>(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, unknown> | Array<Record<string, unknown>>): FrontendModelQuery<T>;
     /**
      * Runs distinct.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {boolean} [value] - Whether to request distinct rows.
      * @returns {FrontendModelQuery<T>} - Query builder with distinct flag.
      */
-    static distinct<T extends typeof FrontendModelBase>(this: T, value?: boolean): FrontendModelQuery<T>;
+    static distinct<T extends FrontendModelClass>(this: T, value?: boolean): FrontendModelQuery<T>;
     /**
      * Runs query.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {FrontendModelQuery<T>} - Query builder.
      */
-    static query<T extends typeof FrontendModelBase>(this: T): FrontendModelQuery<T>;
+    static query<T extends FrontendModelClass>(this: T): FrontendModelQuery<T>;
     /**
      * Runs preload.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} preload - Preload graph.
      * @returns {FrontendModelQuery<T>} - Query with preload.
      */
-    static preload<T extends typeof FrontendModelBase>(this: T, preload: import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>): FrontendModelQuery<T>;
+    static preload<T extends FrontendModelClass>(this: T, preload: import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>): FrontendModelQuery<T>;
     /**
      * Runs select.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, string[] | string> | string | string[]} select - Model-aware attribute select map or root-model shorthand.
      * @returns {FrontendModelQuery<T>} - Query with selected attributes.
      */
-    static select<T extends typeof FrontendModelBase>(this: T, select: Record<string, string[] | string> | string | string[]): FrontendModelQuery<T>;
+    static select<T extends FrontendModelClass>(this: T, select: Record<string, string[] | string> | string | string[]): FrontendModelQuery<T>;
     /**
      * Runs selects extra.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, string[] | string> | string | string[]} select - Extra attributes to load in addition to the defaults, keyed by model name or root-model shorthand.
      * @returns {FrontendModelQuery<T>} - Query with extra selected attributes.
      */
-    static selectsExtra<T extends typeof FrontendModelBase>(this: T, select: Record<string, string[] | string> | string | string[]): FrontendModelQuery<T>;
+    static selectsExtra<T extends FrontendModelClass>(this: T, select: Record<string, string[] | string> | string | string[]): FrontendModelQuery<T>;
     /**
      * Runs first.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {Promise<InstanceType<T> | null>} - First model or null.
      */
-    static first<T extends typeof FrontendModelBase>(this: T): Promise<InstanceType<T> | null>;
+    static first<T extends FrontendModelClass>(this: T): Promise<InstanceType<T> | null>;
     /**
      * Runs last.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @returns {Promise<InstanceType<T> | null>} - Last model or null.
      */
-    static last<T extends typeof FrontendModelBase>(this: T): Promise<InstanceType<T> | null>;
+    static last<T extends FrontendModelClass>(this: T): Promise<InstanceType<T> | null>;
     /**
      * Runs find or initialize by.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} conditions - Attribute match conditions.
      * @returns {Promise<InstanceType<T>>} - Existing or initialized model.
      */
-    static findOrInitializeBy<T extends typeof FrontendModelBase>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
+    static findOrInitializeBy<T extends FrontendModelClass>(this: T, conditions: Record<string, unknown>): Promise<InstanceType<T>>;
     /**
      * Runs find or create by.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} 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 typeof FrontendModelBase>(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, unknown>, callback?: (model: InstanceType<T>) => Promise<void> | void): Promise<InstanceType<T>>;
     /**
      * Runs create.
-     * @template {typeof FrontendModelBase} T
+     * @template {FrontendModelClass} T
      * @this {T}
      * @param {Record<string, ?>} [attributes] - Initial attributes.
      * @returns {Promise<InstanceType<T>>} - Persisted model.
      */
-    static create<T extends typeof FrontendModelBase>(this: T, attributes?: Record<string, unknown>): Promise<InstanceType<T>>;
+    static create<T extends FrontendModelClass>(this: T, attributes?: Record<string, unknown>): Promise<InstanceType<T>>;
     /**
      * Runs assert find by conditions.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {Record<string, ?>} conditions - findBy conditions.
      * @returns {void}
      */
-    static assertFindByConditions(this: typeof FrontendModelBase, conditions: Record<string, unknown>): void;
+    static assertFindByConditions(this: FrontendModelClass, conditions: Record<string, unknown>): void;
     /**
      * Runs matches find by conditions.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {FrontendModelBase} model - Candidate model.
      * @param {Record<string, ?>} conditions - Match conditions.
      * @returns {boolean} - Whether the model matches all conditions.
      */
-    static matchesFindByConditions(this: typeof FrontendModelBase, model: FrontendModelBase, conditions: Record<string, unknown>): boolean;
+    static matchesFindByConditions(this: FrontendModelClass, model: FrontendModelBase, conditions: Record<string, unknown>): boolean;
     /**
      * Runs find by condition value matches.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {?} actualValue - Actual model value.
      * @param {?} expectedValue - Expected find condition value.
      * @returns {boolean} - Whether values match.
      */
-    static findByConditionValueMatches(this: typeof FrontendModelBase, actualValue: unknown, expectedValue: unknown): boolean;
+    static findByConditionValueMatches(this: FrontendModelClass, actualValue: unknown, expectedValue: unknown): boolean;
     /**
      * Runs find by primitive values match.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {?} actualValue - Actual model value.
      * @param {?} expectedValue - Expected find condition value.
      * @returns {boolean} - Whether primitive values match after safe coercion.
      */
-    static findByPrimitiveValuesMatch(this: typeof FrontendModelBase, actualValue: unknown, expectedValue: unknown): boolean;
+    static findByPrimitiveValuesMatch(this: FrontendModelClass, actualValue: unknown, expectedValue: unknown): boolean;
     /**
      * Runs find by numeric string matches number.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {string} numericString - Numeric string value.
      * @param {number} expectedNumber - Number value.
      * @returns {boolean} - Whether values represent the same number.
      */
-    static findByNumericStringMatchesNumber(this: typeof FrontendModelBase, numericString: string, expectedNumber: number): boolean;
+    static findByNumericStringMatchesNumber(this: FrontendModelClass, numericString: string, expectedNumber: number): boolean;
     /**
      * Runs execute command.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {FrontendModelCommandType} commandType - Command type.
      * @param {Record<string, ?>} payload - Command payload.
      * @returns {Promise<Record<string, ?>>} - Parsed JSON response.
      */
-    static executeCommand(this: typeof FrontendModelBase, commandType: FrontendModelCommandType, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    static executeCommand(this: FrontendModelClass, commandType: FrontendModelCommandType, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
     /**
      * Runs execute custom command.
-     * @this {typeof FrontendModelBase}
+     * @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.
@@ -818,7 +848,7 @@ export default class FrontendModelBase {
      * @param {string} args.resourcePath - Direct resource path.
      * @returns {Promise<Record<string, ?>>} - Decoded response payload.
      */
-    static executeCustomCommand(this: typeof FrontendModelBase, { commandName, commandType, memberId, payload, resourcePath }: {
+    static executeCustomCommand(this: FrontendModelClass, { commandName, commandType, memberId, payload, resourcePath }: {
         commandName: string;
         commandType: FrontendModelRequestCommandType;
         memberId?: string | number | null | undefined;
@@ -827,22 +857,22 @@ export default class FrontendModelBase {
     }): Promise<Record<string, unknown>>;
     /**
      * Runs throw on error frontend model response.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @param {object} args - Arguments.
      * @param {FrontendModelRequestCommandType} args.commandType - Command type.
      * @param {Record<string, ?>} args.response - Decoded response.
      * @returns {void}
      */
-    static throwOnErrorFrontendModelResponse(this: typeof FrontendModelBase, { commandType, response }: {
+    static throwOnErrorFrontendModelResponse(this: FrontendModelClass, { commandType, response }: {
         commandType: FrontendModelRequestCommandType;
         response: Record<string, unknown>;
     }): void;
     /**
      * Runs configured frontend model attribute names.
-     * @this {typeof FrontendModelBase}
+     * @this {FrontendModelClass}
      * @returns {Set<string>} - Configured frontend model attribute names.
      */
-    static configuredFrontendModelAttributeNames(this: typeof FrontendModelBase): Set<string>;
+    static configuredFrontendModelAttributeNames(this: FrontendModelClass): Set<string>;
     /**
      * Runs constructor.
      * @param {Record<string, ?>} [attributes] - Initial attributes.
@@ -854,12 +884,17 @@ export default class FrontendModelBase {
     _attributes: Record<string, unknown>;
     /**
      * Narrows the runtime value to the documented type.
-      @type {Record<string, FrontendModelHasManyRelationship<typeof FrontendModelBase, typeof FrontendModelBase> | FrontendModelSingularRelationship<typeof FrontendModelBase, typeof FrontendModelBase>>} */
-    _relationships: Record<string, FrontendModelHasManyRelationship<typeof FrontendModelBase, typeof FrontendModelBase> | FrontendModelSingularRelationship<typeof FrontendModelBase, typeof FrontendModelBase>>;
+      @type {Record<string, FrontendModelHasManyRelationship<FrontendModelClass, FrontendModelClass> | FrontendModelSingularRelationship<FrontendModelClass, FrontendModelClass>>} */
+    _relationships: Record<string, FrontendModelHasManyRelationship<FrontendModelClass, FrontendModelClass> | FrontendModelSingularRelationship<FrontendModelClass, FrontendModelClass>>;
     /**
      * 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} */
@@ -927,9 +962,9 @@ export default class FrontendModelBase {
     /**
      * Runs get relationship by name.
      * @param {string} relationshipName - Relationship name.
-     * @returns {FrontendModelHasManyRelationship<typeof FrontendModelBase, typeof FrontendModelBase> | FrontendModelSingularRelationship<typeof FrontendModelBase, typeof FrontendModelBase>} - Relationship state object.
+     * @returns {FrontendModelHasManyRelationship<FrontendModelClass, FrontendModelClass> | FrontendModelSingularRelationship<FrontendModelClass, FrontendModelClass>} - Relationship state object.
      */
-    getRelationshipByName(relationshipName: string): FrontendModelHasManyRelationship<typeof FrontendModelBase, typeof FrontendModelBase> | FrontendModelSingularRelationship<typeof FrontendModelBase, typeof FrontendModelBase>;
+    getRelationshipByName(relationshipName: string): FrontendModelHasManyRelationship<FrontendModelClass, FrontendModelClass> | FrontendModelSingularRelationship<FrontendModelClass, FrontendModelClass>;
     /**
      * Runs get attachment by name.
      * @param {string} attachmentName - Attachment name.
@@ -949,11 +984,11 @@ export default class FrontendModelBase {
      * 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<typeof FrontendModelBase> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} queryOrSpec - Preload source.
+     * @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<typeof FrontendModelBase> | import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>, options?: {
+    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>;
     /**
@@ -1094,13 +1129,13 @@ export default class FrontendModelBase {
      * 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: InstanceType<typeof FrontendModelBase>}) => void} callback - Event callback.
+     * @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: InstanceType<typeof FrontendModelBase>;
+        model: FrontendModelBase;
     }) => void, options?: import("./query.js").FrontendModelEventOptions): Promise<() => void>;
     /**
      * Instance-level hook fired when THIS record is destroyed.
@@ -1149,6 +1184,13 @@ export default class FrontendModelBase {
      * @returns {Promise<void>} - Resolves when destroyed on backend.
      */
     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.
+     */
+    _buildAttachmentsPayload(): Promise<Record<string, unknown>>;
+    /** Clears queued attachment inputs after a successful save. */
+    _clearPendingAttachments(): void;
     /**
      * Walks relationships declared in this resource's `nestedAttributes` config
      * and builds the per-relationship payload of dirty children for a parent save.
@@ -1161,16 +1203,39 @@ export default class FrontendModelBase {
      *
      * Loaded but untouched records are omitted so nested save preserves Rails-style
      * "children not referenced in payload are left alone" semantics.
-     * @returns {Record<string, Array<Record<string, ?>>>} - Per-relationship list of nested-attribute entries.
+     * @returns {Promise<Record<string, Array<Record<string, ?>>>>} - Per-relationship list of nested-attribute entries.
      */
-    _buildNestedAttributesPayload(): Record<string, Array<Record<string, unknown>>>;
+    _buildNestedAttributesPayload(): Promise<Record<string, Array<Record<string, unknown>>>>;
     /**
      * 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 {Record<string, ?> | null} - Nested-attribute entry or null if clean.
+     * @returns {Promise<Record<string, ?> | null>} - Nested-attribute entry or null if clean.
+     */
+    _nestedAttributesEntryForParentSave(): Promise<Record<string, unknown> | 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.
+     */
+    _nestedAttributesPayloadForSubmittedValue(ModelClass: FrontendModelClass, relationshipName: string, value: unknown): Promise<Array<Record<string, unknown>>>;
+    /**
+     * 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.
+     */
+    _nestedAttributesEntryPayloadForSubmittedValue(ModelClass: FrontendModelClass, submittedEntry: unknown): Promise<Record<string, unknown>>;
+    /**
+     * 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.
      */
-    _nestedAttributesEntryForParentSave(): Record<string, unknown> | null;
+    _attachmentPayloadForSubmittedValue(ModelClass: FrontendModelClass, attachmentName: string, value: unknown): Promise<Record<string, unknown> | Record<string, unknown>[]>;
     /**
      * After a parent save with `nestedAttributes`, the server response includes
      * preloaded versions of the affected relationships. This replaces the local
@@ -1188,7 +1253,7 @@ export default class FrontendModelBase {
 export type FrontendModelModelEventCallbackEntry = {
     callback: (payload: {
         id: string;
-        model: InstanceType<typeof FrontendModelBase>;
+        model: FrontendModelBase;
     }) => void;
     eventFilterKey: string | null;
     eventFilterPayload: import("./query.js").FrontendModelEventFilterPayload | null;
@@ -1216,6 +1281,14 @@ export type FrontendModelRequestCommandType = FrontendModelCommandType | string;
 export type FrontendModelAttachmentDefinition = {
     type: "hasOne" | "hasMany";
 };
+/**
+ * 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.
  */
@@ -1235,6 +1308,16 @@ export type FrontendModelResourceConfig = {
     primaryKey?: string;
     relationships?: string[];
 };
+/**
+ * Frontend model constructor type.
+ */
+export type FrontendModelConstructor = {
+    new (attributes?: Record<string, unknown>): FrontendModelBase;
+};
+/**
+ * Frontend model static side without generated per-model create overloads.
+ */
+export type FrontendModelClass = FrontendModelConstructor & Omit<typeof FrontendModelBase, "create">;
 /**
  * FrontendModelTransportConfig type.
  */