velocious 1.0.577 → 1.0.579

package/build/src/frontend-model-controller.d.ts

@@ -1,13 +1,104 @@
+import Controller from "./controller.js";
+export type FrontendModelSearch = {
+    /**
+     * - Relationship path.
+     */
+    path: string[];
+    /**
+     * - Column or attribute name.
+     */
+    column: string;
+    /**
+     * - Search operator.
+     */
+    operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq";
+    /**
+     * - Search value.
+     */
+    value: ReturnType<typeof JSON.parse>;
+};
+export type FrontendModelSort = {
+    /**
+     * - Attribute name to sort by.
+     */
+    column: string;
+    /**
+     * - Sort direction.
+     */
+    direction: "asc" | "desc";
+    /**
+     * - Relationship path from root model.
+     */
+    path: string[];
+};
+export type FrontendModelGroup = {
+    /**
+     * - Attribute name to group by.
+     */
+    column: string;
+    /**
+     * - Relationship path from root model.
+     */
+    path: string[];
+};
+export type FrontendModelPluck = {
+    /**
+     * - Attribute name to pluck.
+     */
+    column: string;
+    /**
+     * - Relationship path from root model.
+     */
+    path: string[];
+};
+export type FrontendModelPagination = {
+    /**
+     * - Maximum number of records.
+     */
+    limit: number | null;
+    /**
+     * - Number of records to skip.
+     */
+    offset: number | null;
+    /**
+     * - 1-based page number.
+     */
+    page: number | null;
+    /**
+     * - Page size.
+     */
+    perPage: number | null;
+};
+export type FrontendModelEndpointErrorContext = import("./configuration-types.js").ClientErrorPayloadContext & {
+    action: string;
+    expectedError: boolean;
+    frontendModelEndpoint: true;
+};
+export type FrontendModelIndexQueryOptions = {
+    /**
+     * - Whether frontend-model pagination params should be applied.
+     */
+    includePagination?: boolean;
+    /**
+     * - Whether frontend-model sort params should be applied.
+     */
+    includeSort?: boolean;
+    /**
+     * - Resource providing query hooks.
+     */
+    resource?: import("./frontend-model-resource/base-resource.js").default;
+};
+export type FrontendModelQueryMetadata = import("./database/query/model-class-query.js").default & Record<symbol, Set<string> | undefined>;
 /** Controller with built-in frontend model resource actions. */
 export default class FrontendModelController extends Controller {
     /**
      * Frontend model params.
-     * @type {Record<string, ?> | undefined} */
-    _frontendModelParams: Record<string, unknown> | undefined;
+     * @type {Record<string, ReturnType<typeof JSON.parse>> | undefined} */
+    _frontendModelParams: Record<string, ReturnType<typeof JSON.parse>> | undefined;
     /**
      * Frontend model params override.
-     * @type {Record<string, ?> | undefined} */
-    _frontendModelParamsOverride: Record<string, unknown> | undefined;
+     * @type {Record<string, ReturnType<typeof JSON.parse>> | undefined} */
+    _frontendModelParamsOverride: Record<string, ReturnType<typeof JSON.parse>> | undefined;
     /**
      * Frontend model ability override.
      * @type {import("./authorization/ability.js").default | undefined} */
@@ -16,30 +107,35 @@ export default class FrontendModelController extends Controller {
      * Original deserialized custom-command client payload, captured before route
      * framework params are merged in, so a typed command method receives the client's
      * own arguments rather than the route metadata. Only set on the shared-endpoint path.
-     * @type {Record<string, ?> | undefined} */
-    _frontendModelCustomCommandClientArguments: Record<string, unknown> | undefined;
+     * @type {Record<string, ReturnType<typeof JSON.parse>> | undefined} */
+    _frontendModelCustomCommandClientArguments: Record<string, ReturnType<typeof JSON.parse>> | undefined;
     /**
      * Runs frontend model params.
-     * @returns {Record<string, ?>} - Decoded request params.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Decoded request params.
      */
-    frontendModelParams(): Record<string, unknown>;
+    frontendModelParams(): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Runs with frontend model params.
      * @template T
-     * @param {Record<string, ?>} params - Temporary frontend model params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Temporary frontend model params.
      * @param {() => Promise<T>} callback - Callback executed with temporary params.
      * @returns {Promise<T>} - Callback return value.
      */
-    withFrontendModelParams<T>(params: Record<string, unknown>, callback: () => Promise<T>): Promise<T>;
+    withFrontendModelParams<T>(params: Record<string, ReturnType<typeof JSON.parse>>, callback: () => Promise<T>): Promise<T>;
     /**
      * Runs with frontend model request context.
      * @template T
-     * @param {Record<string, ?>} params - Request-scoped params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request-scoped params.
      * @param {import("./http-server/client/response.js").default} response - Response instance.
      * @param {() => Promise<T>} callback - Callback executed inside resolved tenant and ability context.
      * @returns {Promise<T>} - Callback return value.
      */
-    withFrontendModelRequestContext<T>(params: Record<string, unknown>, response: import("./http-server/client/response.js").default, callback: () => Promise<T>): Promise<T>;
+    withFrontendModelRequestContext<T>(params: Record<string, ReturnType<typeof JSON.parse>>, response: import("./http-server/client/response.js").default, callback: () => Promise<T>): Promise<T>;
+    /**
+     * Runs current ability.
+     * @returns {import("./authorization/ability.js").default | undefined} - Current ability for frontend-model request scope.
+     */
+    currentAbility(): import("./authorization/ability.js").default | undefined;
     /**
      * Runs frontend model class.
      * @returns {typeof import("./database/record/index.js").default} - Frontend model class for controller resource actions.
@@ -146,10 +242,10 @@ export default class FrontendModelController extends Controller {
     /**
      * Runs frontend model resource path.
      * @param {string} modelName - Model class name.
-     * @param {?} resourceDefinition - Resource definition.
+     * @param {ReturnType<typeof JSON.parse>} resourceDefinition - Resource definition.
      * @returns {string} - Normalized resource path.
      */
-    frontendModelResourcePath(modelName: string, resourceDefinition: unknown): string;
+    frontendModelResourcePath(modelName: string, resourceDefinition: ReturnType<typeof JSON.parse>): string;
     /**
      * Runs frontend model resource matches controller.
      * @param {object} args - Arguments.
@@ -221,12 +317,12 @@ export default class FrontendModelController extends Controller {
     frontendModelFindRecord(action: "find" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url", id: string | number): Promise<import("./database/record/index.js").default | null>;
     /**
      * Runs frontend model create record.
-     * @param {Record<string, ?>} attributes - Create attributes.
-     * @param {Record<string, ?> | null} [nestedAttributes] - Optional nested-attribute payload for cascading writes.
-     * @param {Record<string, ?> | null} [attachments] - Optional attachment payloads keyed by attachment name.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} attributes - Create attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>> | null} [nestedAttributes] - Optional nested-attribute payload for cascading writes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>> | null} [attachments] - Optional attachment payloads keyed by attachment name.
      * @returns {Promise<import("./database/record/index.js").default | null>} - Created model when authorized.
      */
-    frontendModelCreateRecord(attributes: Record<string, unknown>, nestedAttributes?: Record<string, unknown> | null, attachments?: Record<string, unknown> | null): Promise<import("./database/record/index.js").default | null>;
+    frontendModelCreateRecord(attributes: Record<string, ReturnType<typeof JSON.parse>>, nestedAttributes?: Record<string, ReturnType<typeof JSON.parse>> | null, attachments?: Record<string, ReturnType<typeof JSON.parse>> | null): Promise<import("./database/record/index.js").default | null>;
     /**
      * Runs frontend model records.
      * @returns {Promise<import("./database/record/index.js").default[]>} - Frontend model records.
@@ -254,19 +350,19 @@ export default class FrontendModelController extends Controller {
     frontendModelSearches(): FrontendModelSearch[];
     /**
      * Runs frontend model where.
-     * @returns {Record<string, ?> | null} - Frontend where filters.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>> | null} - Frontend where filters.
      */
-    frontendModelWhere(): Record<string, unknown> | null;
+    frontendModelWhere(): Record<string, ReturnType<typeof JSON.parse>> | null;
     /**
      * Runs frontend model ransack.
-     * @returns {Record<string, ?> | null} - Frontend Ransack filters.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>> | null} - Frontend Ransack filters.
      */
-    frontendModelRansack(): Record<string, unknown> | null;
+    frontendModelRansack(): Record<string, ReturnType<typeof JSON.parse>> | null;
     /**
      * Runs frontend model joins.
-     * @returns {Record<string, ?> | null} - Frontend joins descriptors.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>> | null} - Frontend joins descriptors.
      */
-    frontendModelJoins(): Record<string, unknown> | null;
+    frontendModelJoins(): Record<string, ReturnType<typeof JSON.parse>> | null;
     /**
      * Runs frontend model sort.
      * @returns {FrontendModelSort[]} - Frontend sort definitions.
@@ -299,13 +395,13 @@ export default class FrontendModelController extends Controller {
     frontendModelCountRequested(): boolean;
     /**
      * Runs frontend model with count.
-     * @returns {Array<{attributeName: string, relationshipName: string, where?: Record<string, ?>}>}
+     * @returns {Array<{attributeName: string, relationshipName: string, where?: Record<string, ReturnType<typeof JSON.parse>>}>}
      *   Frontend withCount entries. Empty array when not requested.
      */
     frontendModelWithCount(): Array<{
         attributeName: string;
         relationshipName: string;
-        where?: Record<string, unknown>;
+        where?: Record<string, ReturnType<typeof JSON.parse>>;
     }>;
     /**
      * Resolve an entry from the frontend-model `abilities` payload to
@@ -383,12 +479,12 @@ export default class FrontendModelController extends Controller {
      * @param {object} args - Pluck args.
      * @param {import("./database/query/model-class-query.js").default} args.query - Query instance.
      * @param {FrontendModelPluck[]} args.pluck - Pluck descriptors.
-     * @returns {Promise<Array<?>>} - Plucked values.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - Plucked values.
      */
     frontendModelPluckValues({ query, pluck }: {
         query: import("./database/query/model-class-query.js").default;
         pluck: FrontendModelPluck[];
-    }): Promise<Array<unknown>>;
+    }): Promise<Array<ReturnType<typeof JSON.parse>>>;
     /**
      * Resolves a frontend-model pluck attribute to a database column.
      * @param {{attributeName: string, modelClass: typeof import("./database/record/index.js").default}} args - Arguments.
@@ -418,16 +514,16 @@ export default class FrontendModelController extends Controller {
     assertFrontendModelPluckDefinitionsAllowed(pluck: FrontendModelPluck[]): void;
     /**
      * Asserts frontend-model Ransack definitions only reference exposed resource attributes.
-     * @param {Record<string, ?>} ransack - Ransack descriptor.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} ransack - Ransack descriptor.
      * @returns {void}
      */
-    assertFrontendModelRansackAllowed(ransack: Record<string, unknown>): void;
+    assertFrontendModelRansackAllowed(ransack: Record<string, ReturnType<typeof JSON.parse>>): void;
     /**
      * Runs normalized frontend-model Ransack group.
-     * @param {Record<string, ?>} filterParams - Ransack filter params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} filterParams - Ransack filter params.
      * @returns {import("./utils/ransack.js").RansackGroup} Normalized Ransack group.
      */
-    frontendModelRansackGroup(filterParams: Record<string, unknown>): import("./utils/ransack.js").RansackGroup;
+    frontendModelRansackGroup(filterParams: Record<string, ReturnType<typeof JSON.parse>>): import("./utils/ransack.js").RansackGroup;
     /**
      * Runs normalized frontend-model Ransack sorts.
      * @param {string} sortString - Ransack sort string.
@@ -510,28 +606,28 @@ export default class FrontendModelController extends Controller {
      * Runs apply frontend model where.
      * @param {object} args - Where args.
      * @param {import("./database/query/model-class-query.js").default} args.query - Query instance.
-     * @param {Record<string, ?>} args.where - Root-model where conditions.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.where - Root-model where conditions.
      * @returns {void}
      */
     applyFrontendModelWhere({ query, where }: {
         query: import("./database/query/model-class-query.js").default;
-        where: Record<string, unknown>;
+        where: Record<string, ReturnType<typeof JSON.parse>>;
     }): void;
     /**
      * Runs apply frontend model joins.
      * @param {object} args - Joins args.
-     * @param {Record<string, ?>} args.joins - Relationship-object joins.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.joins - Relationship-object joins.
      * @param {import("./database/query/model-class-query.js").default} args.query - Query instance.
      * @returns {void}
      */
     applyFrontendModelJoins({ joins, query }: {
-        joins: Record<string, unknown>;
+        joins: Record<string, ReturnType<typeof JSON.parse>>;
         query: import("./database/query/model-class-query.js").default;
     }): void;
     /**
      * Runs apply frontend model joins for path.
      * @param {object} args - Joins args.
-     * @param {Record<string, ?>} args.joins - Joins for current path.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.joins - Joins for current path.
      * @param {Set<string>} args.joinPathKeys - Joined path keys.
      * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class for current path.
      * @param {string[]} args.path - Relationship path.
@@ -539,7 +635,7 @@ export default class FrontendModelController extends Controller {
      * @returns {void}
      */
     applyFrontendModelJoinsForPath({ joins, joinPathKeys, modelClass, path, query }: {
-        joins: Record<string, unknown>;
+        joins: Record<string, ReturnType<typeof JSON.parse>>;
         joinPathKeys: Set<string>;
         modelClass: typeof import("./database/record/index.js").default;
         path: string[];
@@ -610,28 +706,28 @@ export default class FrontendModelController extends Controller {
      * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class for current where scope.
      * @param {string[]} args.path - Relationship path from root.
      * @param {import("./database/query/model-class-query.js").default} args.query - Query instance.
-     * @param {Record<string, ?>} args.where - Where conditions for current scope.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.where - Where conditions for current scope.
      * @returns {void}
      */
     applyFrontendModelWhereForPath({ modelClass, path, query, where }: {
         modelClass: typeof import("./database/record/index.js").default;
         path: string[];
         query: import("./database/query/model-class-query.js").default;
-        where: Record<string, unknown>;
+        where: Record<string, ReturnType<typeof JSON.parse>>;
     }): void;
     /**
      * Runs normalize frontend model where column value.
      * @param {object} args - Args.
      * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class.
      * @param {string} args.columnName - Column name.
-     * @param {?} args.value - Where value.
-     * @returns {? | symbol} - SQL-safe where value.
+     * @param {ReturnType<typeof JSON.parse>} args.value - Where value.
+     * @returns {ReturnType<typeof JSON.parse> | symbol} - SQL-safe where value.
      */
     normalizeFrontendModelWhereColumnValue({ columnName, modelClass, value }: {
         modelClass: typeof import("./database/record/index.js").default;
         columnName: string;
-        value: unknown;
-    }): unknown | symbol;
+        value: ReturnType<typeof JSON.parse>;
+    }): ReturnType<typeof JSON.parse> | symbol;
     /**
      * Runs apply frontend model group.
      * @param {object} args - Group args.
@@ -735,9 +831,9 @@ export default class FrontendModelController extends Controller {
     /**
      * Runs serialize frontend model attributes.
      * @param {import("./database/record/index.js").default} model - Model instance.
-     * @returns {Promise<Record<string, ?>>} - Serialized attributes filtered by select map.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Serialized attributes filtered by select map.
      */
-    serializeFrontendModelAttributes(model: import("./database/record/index.js").default): Promise<Record<string, unknown>>;
+    serializeFrontendModelAttributes(model: import("./database/record/index.js").default): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Runs serialization resource instance for model.
      * @param {import("./database/record/index.js").default} model - Model instance.
@@ -757,22 +853,22 @@ export default class FrontendModelController extends Controller {
     }): Promise<import("./database/record/index.js").default[]>;
     /**
      * Runs is serializable frontend model.
-     * @param {?} value - Candidate preloaded value.
+     * @param {ReturnType<typeof JSON.parse>} value - Candidate preloaded value.
      * @returns {value is import("./database/record/index.js").default} - Whether value behaves like a model.
      */
-    isSerializableFrontendModel(value: unknown): value is import("./database/record/index.js").default;
+    isSerializableFrontendModel(value: ReturnType<typeof JSON.parse>): value is import("./database/record/index.js").default;
     /**
      * Runs serialize frontend models.
      * @param {import("./database/record/index.js").default[]} models - Models to serialize.
-     * @returns {Promise<Record<string, ?>[]>} - Serialized model payloads.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>[]>} - Serialized model payloads.
      */
-    serializeFrontendModels(models: import("./database/record/index.js").default[]): Promise<Record<string, unknown>[]>;
+    serializeFrontendModels(models: import("./database/record/index.js").default[]): Promise<Record<string, ReturnType<typeof JSON.parse>>[]>;
     /**
      * Runs serialize frontend model.
      * @param {import("./database/record/index.js").default} model - Frontend model record.
-     * @returns {Promise<Record<string, ?>>} - Serialized frontend model payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Serialized frontend model payload.
      */
-    serializeFrontendModel(model: import("./database/record/index.js").default): Promise<Record<string, unknown>>;
+    serializeFrontendModel(model: import("./database/record/index.js").default): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Runs frontend model render error.
      * @param {string} errorMessage - Error message.
@@ -782,14 +878,20 @@ export default class FrontendModelController extends Controller {
     /**
      * Runs frontend model error payload.
      * @param {string} errorMessage - Error message.
-     * @returns {Record<string, ?>} - Error payload.
+     * @param {object} [options] - Structured error fields.
+     * @param {import("./configuration-types.js").ClientErrorPayloadReporterPayload} [options.details] - Client-safe details.
+     * @param {"application_error" | "authorization_error" | "internal_error" | "record_not_found" | "validation_error"} [options.errorType] - Stable client-facing error category.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Error payload.
      */
-    frontendModelErrorPayload(errorMessage: string): Record<string, unknown>;
+    frontendModelErrorPayload(errorMessage: string, options?: {
+        details?: import("./configuration-types.js").ClientErrorPayloadReporterPayload;
+        errorType?: "application_error" | "authorization_error" | "internal_error" | "record_not_found" | "validation_error";
+    }): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Runs frontend model client safe error payload.
-     * @returns {Record<string, ?>} - Client-safe error payload.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Client-safe error payload.
      */
-    frontendModelClientSafeErrorPayload(): Record<string, unknown>;
+    frontendModelClientSafeErrorPayload(): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Builds frontend-model endpoint error context for logging and client payload reporters.
      * @param {object} args - Error context args.
@@ -803,7 +905,7 @@ export default class FrontendModelController extends Controller {
     frontendModelEndpointErrorContext({ action, commandType, error, model, requestId }: {
         action: string;
         error: unknown;
-        commandType?: "find" | "update" | "destroy" | "url" | "index" | "create" | "attach" | "attachmentList" | "download" | "custom-command" | undefined;
+        commandType?: "index" | "find" | "create" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url" | "custom-command";
         model?: string | undefined;
         requestId?: string | undefined;
     }): FrontendModelEndpointErrorContext;
@@ -817,19 +919,13 @@ export default class FrontendModelController extends Controller {
     /**
      * Runs frontend model log endpoint error.
      * @param {object} args - Error log args.
-     * @param {string} args.action - Endpoint/action label.
-     * @param {?} args.error - Caught error.
-     * @param {"index" | "find" | "create" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url" | "custom-command"} [args.commandType] - Frontend-model command type.
-     * @param {string | undefined} [args.model] - Request model name when available.
-     * @param {string | undefined} [args.requestId] - Batch request id when available.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Caught error.
+     * @param {FrontendModelEndpointErrorContext} args.errorContext - Shared client/logging error context.
      * @returns {Promise<void>} - Resolves after logging.
      */
-    frontendModelLogEndpointError({ action, error, commandType, model, requestId }: {
-        action: string;
-        error: unknown;
-        commandType?: "find" | "update" | "destroy" | "url" | "index" | "create" | "attach" | "attachmentList" | "download" | "custom-command" | undefined;
-        model?: string | undefined;
-        requestId?: string | undefined;
+    frontendModelLogEndpointError({ error, errorContext }: {
+        error: ReturnType<typeof JSON.parse>;
+        errorContext: FrontendModelEndpointErrorContext;
     }): Promise<void>;
     /**
      * Runs frontend model render command response.
@@ -840,9 +936,9 @@ export default class FrontendModelController extends Controller {
     /**
      * Runs frontend model command payload.
      * @param {"index" | "find" | "create" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url"} action - Frontend action.
-     * @returns {Promise<Record<string, ?> | null>} - Response payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Response payload.
      */
-    frontendModelCommandPayload(action: "index" | "find" | "create" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url"): Promise<Record<string, unknown> | null>;
+    frontendModelCommandPayload(action: "index" | "find" | "create" | "update" | "destroy" | "attach" | "attachmentList" | "download" | "url"): Promise<Record<string, ReturnType<typeof JSON.parse>> | null>;
     /**
      * Runs frontend sync bootstrap.
      * @returns {Promise<void>} - Sync bootstrap response with manifest and signed offline grant.
@@ -884,36 +980,36 @@ export default class FrontendModelController extends Controller {
     frontendSyncReplay(): Promise<void>;
     /**
      * Resolves signed replay mutations from request params.
-     * @param {Record<string, ?>} params - Request params.
-     * @returns {Array<?>} - Signed mutation envelopes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @returns {Array<ReturnType<typeof JSON.parse>>} - Signed mutation envelopes.
      */
-    frontendSyncReplaySignedMutations(params: Record<string, unknown>): Array<unknown>;
+    frontendSyncReplaySignedMutations(params: Record<string, ReturnType<typeof JSON.parse>>): Array<ReturnType<typeof JSON.parse>>;
     /**
      * Verifies and replays one signed sync mutation.
-     * @param {?} signedMutation - Signed mutation envelope.
-     * @returns {Promise<{response: Record<string, ?>, serverChangeFeedError?: Record<string, ?>, serverChangeFeedStatus?: "error", serverSequence: number | null}>} - Frontend-model command response and appended server sequence.
+     * @param {ReturnType<typeof JSON.parse>} signedMutation - Signed mutation envelope.
+     * @returns {Promise<{response: Record<string, ReturnType<typeof JSON.parse>>, serverChangeFeedError?: Record<string, ReturnType<typeof JSON.parse>>, serverChangeFeedStatus?: "error", serverSequence: number | null}>} - Frontend-model command response and appended server sequence.
      */
-    frontendSyncReplaySignedMutation(signedMutation: unknown): Promise<{
-        response: Record<string, unknown>;
-        serverChangeFeedError?: Record<string, unknown>;
+    frontendSyncReplaySignedMutation(signedMutation: ReturnType<typeof JSON.parse>): Promise<{
+        response: Record<string, ReturnType<typeof JSON.parse>>;
+        serverChangeFeedError?: Record<string, ReturnType<typeof JSON.parse>>;
         serverChangeFeedStatus?: "error";
         serverSequence: number | null;
     }>;
     /**
      * Resolves the signed offline grant carried by a replay request.
-     * @param {?} signedMutation - Signed mutation envelope.
-     * @returns {?} - Signed offline grant envelope.
+     * @param {ReturnType<typeof JSON.parse>} signedMutation - Signed mutation envelope.
+     * @returns {ReturnType<typeof JSON.parse>} - Signed offline grant envelope.
      */
-    frontendSyncReplaySignedOfflineGrant(signedMutation: unknown): unknown;
+    frontendSyncReplaySignedOfflineGrant(signedMutation: ReturnType<typeof JSON.parse>): ReturnType<typeof JSON.parse>;
     /**
      * Verifies a sync replay signed offline grant.
      * @param {object} args - Arguments.
-     * @param {?} args.signedOfflineGrant - Signed offline grant envelope.
+     * @param {ReturnType<typeof JSON.parse>} args.signedOfflineGrant - Signed offline grant envelope.
      * @param {import("./sync/offline-grant.js").OfflineGrantSigningKey[]} args.signingKeys - Available signing keys.
      * @returns {Promise<import("./sync/offline-grant.js").OfflineGrant>} - Verified offline grant.
      */
     frontendSyncReplayVerifiedOfflineGrant({ signedOfflineGrant, signingKeys }: {
-        signedOfflineGrant: unknown;
+        signedOfflineGrant: ReturnType<typeof JSON.parse>;
         signingKeys: import("./sync/offline-grant.js").OfflineGrantSigningKey[];
     }): Promise<import("./sync/offline-grant.js").OfflineGrant>;
     /**
@@ -921,20 +1017,20 @@ export default class FrontendModelController extends Controller {
      * @param {object} args - Arguments.
      * @param {import("./sync/device-identity.js").SyncMutation} args.mutation - Verified mutation.
      * @param {import("./sync/offline-grant.js").OfflineGrant} args.offlineGrant - Verified grant.
-     * @param {Record<string, ?>} args.syncResource - Current sync resource entry.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.syncResource - Current sync resource entry.
      * @returns {void} - Throws when unauthorized.
      */
     frontendSyncReplayValidateOfflineGrant({ mutation, offlineGrant, syncResource }: {
         mutation: import("./sync/device-identity.js").SyncMutation;
         offlineGrant: import("./sync/offline-grant.js").OfflineGrant;
-        syncResource: Record<string, unknown>;
+        syncResource: Record<string, ReturnType<typeof JSON.parse>>;
     }): void;
     /**
      * Replays a verified custom sync mutation through the resource command API.
      * @param {object} args - Arguments.
      * @param {import("./sync/device-identity.js").SyncMutation} args.mutation - Verified mutation.
      * @param {{commandType: string, methodName?: string, scope?: "collection" | "member"}} args.replayCommand - Resolved replay command metadata.
-     * @returns {Promise<Record<string, ?>>} - Command response payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Command response payload.
      */
     frontendSyncReplayCustomCommandPayload({ mutation, replayCommand }: {
         mutation: import("./sync/device-identity.js").SyncMutation;
@@ -943,13 +1039,13 @@ export default class FrontendModelController extends Controller {
             methodName?: string;
             scope?: "collection" | "member";
         };
-    }): Promise<Record<string, unknown>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Builds frontend-model command params for a verified replay mutation.
      * @param {import("./sync/device-identity.js").SyncMutation} mutation - Verified mutation.
-     * @returns {Promise<Record<string, ?>>} - Frontend-model command params.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Frontend-model command params.
      */
-    frontendSyncReplayCommandParams(mutation: import("./sync/device-identity.js").SyncMutation): Promise<Record<string, unknown>>;
+    frontendSyncReplayCommandParams(mutation: import("./sync/device-identity.js").SyncMutation): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Resolves the frontend-model command used for a verified replay mutation.
      * @param {import("./sync/device-identity.js").SyncMutation} mutation - Verified mutation.
@@ -963,10 +1059,10 @@ export default class FrontendModelController extends Controller {
     /**
      * Resolves command attributes and primary key from a replay mutation.
      * @param {import("./sync/device-identity.js").SyncMutation} mutation - Verified mutation.
-     * @returns {Promise<{attributes: Record<string, ?>, primaryKeyValue: string | number | undefined}>} - Command attributes and primary key value.
+     * @returns {Promise<{attributes: Record<string, ReturnType<typeof JSON.parse>>, primaryKeyValue: string | number | undefined}>} - Command attributes and primary key value.
      */
     frontendSyncReplayCommandAttributes(mutation: import("./sync/device-identity.js").SyncMutation): Promise<{
-        attributes: Record<string, unknown>;
+        attributes: Record<string, ReturnType<typeof JSON.parse>>;
         primaryKeyValue: string | number | undefined;
     }>;
     /**
@@ -975,21 +1071,21 @@ export default class FrontendModelController extends Controller {
      * @param {string | null} args.idempotencyKey - Mutation idempotency key.
      * @param {import("./sync/device-identity.js").SyncMutation} args.mutation - Verified mutation.
      * @param {import("./sync/offline-grant.js").OfflineGrant} args.offlineGrant - Verified offline grant.
-     * @param {Record<string, ?>} args.response - Replay command response.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.response - Replay command response.
      * @returns {Promise<number | null>} - Assigned server sequence, or null when no change was appended.
      */
     frontendSyncAppendServerChange({ idempotencyKey, mutation, offlineGrant, response }: {
         idempotencyKey: string | null;
         mutation: import("./sync/device-identity.js").SyncMutation;
         offlineGrant: import("./sync/offline-grant.js").OfflineGrant;
-        response: Record<string, unknown>;
+        response: Record<string, ReturnType<typeof JSON.parse>>;
     }): Promise<number | null>;
     /**
      * Verifies the signed offline grant used to scope sync read endpoints.
-     * @param {Record<string, ?>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
      * @returns {Promise<import("./sync/offline-grant.js").OfflineGrant>} - Verified offline grant.
      */
-    frontendSyncRequestVerifiedOfflineGrant(params: Record<string, unknown>): Promise<import("./sync/offline-grant.js").OfflineGrant>;
+    frontendSyncRequestVerifiedOfflineGrant(params: Record<string, ReturnType<typeof JSON.parse>>): Promise<import("./sync/offline-grant.js").OfflineGrant>;
     /**
      * Runs frontend sync change feed.
      * @returns {Promise<void>} - Sync change-feed response.
@@ -997,23 +1093,23 @@ export default class FrontendModelController extends Controller {
     frontendSyncChangeFeed(): Promise<void>;
     /**
      * Resolves sync change-feed cursor.
-     * @param {Record<string, ?>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
      * @returns {number} - Exclusive lower-bound sequence.
      */
-    frontendSyncChangeFeedAfterSequence(params: Record<string, unknown>): number;
+    frontendSyncChangeFeedAfterSequence(params: Record<string, ReturnType<typeof JSON.parse>>): number;
     /**
      * Resolves sync change-feed page limit.
-     * @param {Record<string, ?>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
      * @returns {number} - Page limit.
      */
-    frontendSyncChangeFeedLimit(params: Record<string, unknown>): number;
+    frontendSyncChangeFeedLimit(params: Record<string, ReturnType<typeof JSON.parse>>): number;
     /**
      * Resolves sync change-feed stable high-water mark.
-     * @param {Record<string, ?>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
      * @param {number} currentServerSequence - Current latest server sequence.
      * @returns {number} - Inclusive upper-bound sequence.
      */
-    frontendSyncChangeFeedUpToSequence(params: Record<string, unknown>, currentServerSequence: number): number;
+    frontendSyncChangeFeedUpToSequence(params: Record<string, ReturnType<typeof JSON.parse>>, currentServerSequence: number): number;
     /**
      * Runs frontend sync snapshot endpoint.
      * @returns {Promise<void>} - Sync snapshot response.
@@ -1023,14 +1119,14 @@ export default class FrontendModelController extends Controller {
      * Builds a snapshot of sync-enabled frontend model resources at a stable server sequence.
      * @param {object} args - Arguments.
      * @param {number} args.serverSequence - Snapshot sequence.
-     * @param {Record<string, ?>} [args.scope] - Caller sync scope.
-     * @returns {Promise<{resources: Record<string, ?>, serverSequence: number}>} - Snapshot payload.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.scope] - Caller sync scope.
+     * @returns {Promise<{resources: Record<string, ReturnType<typeof JSON.parse>>, serverSequence: number}>} - Snapshot payload.
      */
     frontendSyncSnapshotPayload({ scope, serverSequence }: {
         serverSequence: number;
-        scope?: Record<string, any> | undefined;
+        scope?: Record<string, ReturnType<typeof JSON.parse>>;
     }): Promise<{
-        resources: Record<string, unknown>;
+        resources: Record<string, ReturnType<typeof JSON.parse>>;
         serverSequence: number;
     }>;
     /**
@@ -1042,13 +1138,13 @@ export default class FrontendModelController extends Controller {
      * Dispatches a custom frontend-model command through the shared frontend-model API endpoint.
      * @param {object} args - Arguments.
      * @param {string} args.customPath - Custom backend route path.
-     * @param {?} args.payload - Request payload.
-     * @returns {Promise<Record<string, ?>>} - Parsed JSON response payload.
+     * @param {ReturnType<typeof JSON.parse>} args.payload - Request payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Parsed JSON response payload.
      */
     frontendApiCustomCommandPayload({ customPath, payload }: {
         customPath: string;
-        payload: unknown;
-    }): Promise<Record<string, unknown>>;
+        payload: ReturnType<typeof JSON.parse>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Runs frontend index.
      * @returns {Promise<void>} - Collection action for frontend model resources.
@@ -1096,19 +1192,19 @@ export default class FrontendModelController extends Controller {
     frontendCustomCommand(): Promise<void>;
     /**
      * Runs frontend model custom command payload.
-     * @returns {Promise<Record<string, ?>>} - Response payload.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Response payload.
      */
-    frontendModelCustomCommandPayload(): Promise<Record<string, unknown>>;
+    frontendModelCustomCommandPayload(): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Resolves the typed argument object passed to a custom command method. On the
      * shared-endpoint path the original client payload was captured before route
      * framework params were merged, so it is returned verbatim (a client `id` survives
      * a member route). On the direct path it falls back to the request params with the
      * framework keys the command route hook injected stripped out.
-     * @param {Record<string, ?>} params - Deserialized frontend-model params.
-     * @returns {Record<string, ?>} - Client command arguments.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Deserialized frontend-model params.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Client command arguments.
      */
-    frontendModelCustomCommandArguments(params: Record<string, unknown>): Record<string, unknown>;
+    frontendModelCustomCommandArguments(params: Record<string, ReturnType<typeof JSON.parse>>): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Walks a custom-command response payload and replaces any backend `Record`
      * instance with the resource's per-action serialized form so handlers can
@@ -1116,124 +1212,14 @@ export default class FrontendModelController extends Controller {
      * `await this.serialize(record, action)`. Plain objects, arrays, and
      * primitive values pass through and are later encoded by
      * `serializeFrontendModelTransportValue`.
-     * @param {?} value - Payload value.
-     * @param {{serialize: (model: ?, action: string) => Promise<Record<string, ?>>}} resource - Resource instance providing `serialize`.
+     * @param {ReturnType<typeof JSON.parse>} value - Payload value.
+     * @param {{serialize: (model: ReturnType<typeof JSON.parse>, action: string) => Promise<Record<string, ReturnType<typeof JSON.parse>>>}} resource - Resource instance providing `serialize`.
      * @param {string} action - Custom command method name passed to `resource.serialize` for per-action authorization filtering.
      * @param {WeakSet<object>} [seen] - Recursion stack of plain-object containers currently being walked. Membership is added on entry and removed on exit so a container shared between siblings (i.e. referenced twice but not cyclically) is walked on each reference instead of being short-circuited the second time, which would let backend `Record` instances inside it bypass `resource.serialize`.
-     * @returns {Promise<?>} - Payload with backend `Record` instances replaced by serialized markers.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - Payload with backend `Record` instances replaced by serialized markers.
      */
-    autoSerializeFrontendModelsInPayload(value: unknown, resource: {
-        serialize: (model: unknown, action: string) => Promise<Record<string, unknown>>;
-    }, action: string, seen?: WeakSet<object>): Promise<unknown>;
+    autoSerializeFrontendModelsInPayload(value: ReturnType<typeof JSON.parse>, resource: {
+        serialize: (model: ReturnType<typeof JSON.parse>, action: string) => Promise<Record<string, ReturnType<typeof JSON.parse>>>;
+    }, action: string, seen?: WeakSet<object>): Promise<ReturnType<typeof JSON.parse>>;
 }
-/**
- * FrontendModelSearch type.
- */
-export type FrontendModelSearch = {
-    /**
-     * - Relationship path.
-     */
-    path: string[];
-    /**
-     * - Column or attribute name.
-     */
-    column: string;
-    /**
-     * - Search operator.
-     */
-    operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq";
-    /**
-     * - Search value.
-     */
-    value: unknown;
-};
-/**
- * FrontendModelSort type.
- */
-export type FrontendModelSort = {
-    /**
-     * - Attribute name to sort by.
-     */
-    column: string;
-    /**
-     * - Sort direction.
-     */
-    direction: "asc" | "desc";
-    /**
-     * - Relationship path from root model.
-     */
-    path: string[];
-};
-/**
- * FrontendModelGroup type.
- */
-export type FrontendModelGroup = {
-    /**
-     * - Attribute name to group by.
-     */
-    column: string;
-    /**
-     * - Relationship path from root model.
-     */
-    path: string[];
-};
-/**
- * FrontendModelPluck type.
- */
-export type FrontendModelPluck = {
-    /**
-     * - Attribute name to pluck.
-     */
-    column: string;
-    /**
-     * - Relationship path from root model.
-     */
-    path: string[];
-};
-/**
- * FrontendModelPagination type.
- */
-export type FrontendModelPagination = {
-    /**
-     * - Maximum number of records.
-     */
-    limit: number | null;
-    /**
-     * - Number of records to skip.
-     */
-    offset: number | null;
-    /**
-     * - 1-based page number.
-     */
-    page: number | null;
-    /**
-     * - Page size.
-     */
-    perPage: number | null;
-};
-export type FrontendModelEndpointErrorContext = import("./configuration-types.js").ClientErrorPayloadContext & {
-    action: string;
-    expectedError: boolean;
-    frontendModelEndpoint: true;
-};
-/**
- * FrontendModelIndexQueryOptions type.
- */
-export type FrontendModelIndexQueryOptions = {
-    /**
-     * - Whether frontend-model pagination params should be applied.
-     */
-    includePagination?: boolean | undefined;
-    /**
-     * - Whether frontend-model sort params should be applied.
-     */
-    includeSort?: boolean | undefined;
-    /**
-     * - Resource providing query hooks.
-     */
-    resource?: FrontendModelBaseResource<typeof import("./database/record/index.js").default> | undefined;
-};
-export type FrontendModelQueryMetadata = import("./database/query/model-class-query.js").default & Record<symbol, Set<string> | undefined>;
-import Controller from "./controller.js";
-import FrontendModelBaseResource from "./frontend-model-resource/base-resource.js";
 //# sourceMappingURL=frontend-model-controller.d.ts.map