/**
 * FrontendModelSearch type.
 * @typedef {object} FrontendModelSearch
 * @property {string} column - Attribute name to search.
 * @property {"eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq"} operator - Search operator.
 * @property {string[]} path - Relationship path from root model.
 * @property {?} value - Search value.
 */
/**
 * FrontendModelTransportValue type.
 * @typedef {null | boolean | number | string | object} FrontendModelTransportValue
 */
/**
 * Defines this typedef.
 * @typedef {{attributeName: string, relationshipName: string, where?: Record<string, FrontendModelTransportValue>}} FrontendModelWithCountPayloadEntry
 */
/**
 * Defines this typedef.
 * @typedef {{modelName: string, actions: string[]}} FrontendModelAbilitiesPayloadEntry
 */
/**
 * FrontendModelProjectionOptions type.
 * @typedef {object} FrontendModelProjectionOptions
 * @property {Record<string, string[] | string> | string | string[]} [select] - Model-aware attribute select map or root-model shorthand.
 * @property {Record<string, string[] | string> | string | string[]} [selectsExtra] - Extra attributes to load in addition to the defaults, keyed by model name or root-model shorthand.
 * @property {import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} [preload] - Relationship preload tree.
 * @property {string | string[] | Record<string, boolean | {relationship?: string, where?: Record<string, FrontendModelTransportValue>}>} [withCount] - Association count spec.
 * @property {string[] | Record<string, string[]>} [abilities] - Ability actions to compute per record.
 * @property {string | Array<string | Record<string, FrontendModelTransportValue>> | Record<string, FrontendModelTransportValue>} [queryData] - Backend query data names/spec.
 */
/**
 * Defines this typedef.
 * @typedef {FrontendModelProjectionOptions & {query?: FrontendModelQuery<typeof import("./base.js").default>}} FrontendModelEventOptionsObject
 */
/**
 * FrontendModelEventOptions type.
 * @typedef {FrontendModelEventOptionsObject | FrontendModelQuery<typeof import("./base.js").default>} FrontendModelEventOptions
 */
/**
 * FrontendModelProjectionPayload type.
 * @typedef {object} FrontendModelProjectionPayload
 * @property {Record<string, string[]>} [select] - Normalized select map.
 * @property {Record<string, string[]>} [selectsExtra] - Normalized extra select map.
 * @property {import("../database/query/index.js").NestedPreloadRecord} [preload] - Normalized preload tree.
 * @property {FrontendModelWithCountPayloadEntry[]} [withCount] - Normalized count specs.
 * @property {FrontendModelAbilitiesPayloadEntry[]} [abilities] - Normalized ability specs.
 * @property {FrontendModelTransportValue} [queryData] - Normalized queryData spec.
 */
/**
 * FrontendModelEventFilterPayload type.
 * @typedef {object} FrontendModelEventFilterPayload
 * @property {Record<string, FrontendModelTransportValue>} [joins] - Relationship joins needed for matching.
 * @property {FrontendModelSearch[]} [searches] - Search predicates needed for matching.
 * @property {Record<string, FrontendModelTransportValue>} [where] - Structured where predicates needed for matching.
 */
/**
 * Defines this typedef.
 * @typedef {FrontendModelEventFilterPayload & {key: string}} FrontendModelEventFilterPayloadEntry
 */
/**
 * FrontendModelEventOptionsPayload type.
 * @typedef {object} FrontendModelEventOptionsPayload
 * @property {string | null} eventFilterKey - Stable event filter key, or null when no filter is present.
 * @property {FrontendModelEventFilterPayload | null} eventFilterPayload - Normalized event filter payload, or null when unfiltered.
 * @property {FrontendModelProjectionPayload} projectionPayload - Normalized event serialization projection payload.
 */
/**
 * Runs the normalizePreload helper.
 * @param {import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord> | boolean | undefined | null} preload - Preload shorthand.
 * @returns {import("../database/query/index.js").NestedPreloadRecord} - Normalized preload.
 */
export function normalizePreload(preload: import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord> | boolean | undefined | null): import("../database/query/index.js").NestedPreloadRecord;
/**
 * Runs the normalizeSearchOperator helper.
 * @param {string} operator - Raw search operator.
 * @returns {"eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq"} - Normalized operator.
 */
export function normalizeSearchOperator(operator: string): "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq";
/**
 * Runs the normalizeJoins helper.
 * @param {?} joins - Join payload.
 * @returns {Record<string, ?>} - Normalized relationship descriptor joins.
 */
export function normalizeJoins(joins: unknown): Record<string, unknown>;
/**
 * Normalize any supported sort payload into flat sort descriptors.
 * @param {?} sort - Sort payload.
 * @returns {FrontendModelSort[]} - Normalized sort definitions.
 */
export function normalizeSort(sort: unknown): FrontendModelSort[];
/**
 * Normalize any supported group payload into flat group descriptors.
 * @param {?} group - Group payload.
 * @returns {FrontendModelGroup[]} - Normalized group definitions.
 */
export function normalizeGroup(group: unknown): FrontendModelGroup[];
/**
 * Normalize any supported pluck payload into flat pluck descriptors.
 * @param {?} pluck - Pluck payload.
 * @returns {FrontendModelPluck[]} - Normalized pluck definitions.
 */
export function normalizePluck(pluck: unknown): FrontendModelPluck[];
/**
 * Runs the frontendModelEventOptionsPayload helper.
 * @param {typeof import("./base.js").default} modelClass - Frontend model class.
 * @param {FrontendModelEventOptions} [options] - Event query or projection options.
 * @returns {FrontendModelEventOptionsPayload} - Normalized event subscription payload.
 */
export function frontendModelEventOptionsPayload(modelClass: typeof import("./base.js").default, options?: FrontendModelEventOptions): FrontendModelEventOptionsPayload;
/**
 * Query wrapper for frontend model commands.
 * @template {typeof import("./base.js").default} T
 */
export default class FrontendModelQuery<T extends typeof import("./base.js").default> {
    /**
     * Runs constructor.
     * @param {object} args - Constructor args.
     * @param {T} args.modelClass - Frontend model class.
     * @param {import("../database/query/index.js").NestedPreloadRecord} [args.preload] - Preload map.
     */
    constructor({ modelClass, preload }: {
        modelClass: T;
        preload?: import("../database/query/index.js").NestedPreloadRecord | undefined;
    });
    /**
     * Ransack.
      @type {Record<string, ?>[]} */
    _ransack: Record<string, unknown>[];
    /**
     * Searches.
      @type {FrontendModelSearch[]} */
    _searches: FrontendModelSearch[];
    /**
     * Sort.
      @type {FrontendModelSort[]} */
    _sort: FrontendModelSort[];
    /**
     * Group.
      @type {FrontendModelGroup[]} */
    _group: FrontendModelGroup[];
    modelClass: T;
    _preload: import("../database/query/index.js").NestedPreloadRecord;
    _joins: {};
    _where: {};
    /**
     * Narrows the runtime value to the documented type.
      @type {Record<string, string[]>} */
    _select: Record<string, string[]>;
    /**
     * Narrows the runtime value to the documented type.
      @type {Record<string, string[]>} */
    _selectsExtra: Record<string, string[]>;
    _distinct: boolean;
    _limit: number | null;
    _offset: number | null;
    _page: number | null;
    _perPage: number | null;
    /**
     * Narrows the runtime value to the documented type.
      @type {Array<{attributeName: string, relationshipName: string, where?: Record<string, ?>}>} */
    _withCount: Array<{
        attributeName: string;
        relationshipName: string;
        where?: Record<string, unknown>;
    }>;
    /**
     * Narrows the runtime value to the documented type.
      @type {Array<string | Record<string, ?>>} */
    _queryData: Array<string | Record<string, unknown>>;
    /**
     * Per-record ability spec. Normalized to a list of
     * `{modelName, actions}` entries — one entry per model that should
     * have ability results attached. The root query's model class
     * name is implicit via `"__root__"` when the caller used the flat
     * array form.
     * @type {Array<{modelName: string, actions: string[]}>}
     */
    _abilities: Array<{
        modelName: string;
        actions: string[];
    }>;
    /**
     * Tell the backend to evaluate one or more ability actions against
     * each returned record (and its preloaded relations, when keyed by
     * model name) and ship the results back so the frontend can read
     * them via `record.can(action)`.
     *
     * Flat form — applies to the query's own model class:
     *   ```
     *   const timelogs = await Timelog.where({taskId})
     *     .abilities(["update", "destroy"])
     *     .toArray()
     *   timelogs[0].can("update") // → boolean
     *   ```
     *
     * Keyed form — targets records by model name, useful for preloaded
     * children:
     *   ```
     *   const project = await Project
     *     .preload("timelogs")
     *     .abilities({Timelog: ["update", "destroy"]})
     *     .first()
     *   project.timelogs().loaded()[0].can("update") // → boolean
     *   ```
     *
     * Keys in the keyed form are the backend model names (as returned by
     * `ModelClass.getModelName()` / the `modelName` field of the
     * frontend-model resource config). Values are the ability-action
     * strings — typically `"update"` / `"destroy"` / `"create"` /
     * `"read"`, but any custom action registered on the resource's
     * authorization ability is accepted.
     * @param {string[] | Record<string, string[]>} spec
     * @returns {this}
     */
    abilities(spec: string[] | Record<string, string[]>): this;
    /**
     * Runs merge ability entry.
     * @param {{modelName: string, actions: string[]}} entry
     * @returns {void}
     */
    _mergeAbilityEntry(entry: {
        modelName: string;
        actions: string[];
    }): void;
    /**
     * Tell the backend index query to attach one or more association
     * counts to each returned record. Parses the same shapes as the
     * backend `ModelClassQuery#withCount`, then ships the normalized
     * entries as part of the `index` command payload.
     * @param {string | string[] | Record<string, boolean | {relationship?: string, where?: Record<string, ?>}>} spec
     * @returns {this}
     */
    withCount(spec: string | string[] | Record<string, boolean | {
        relationship?: string;
        where?: Record<string, unknown>;
    }>): this;
    /**
     * Request one or more backend queryData entries for each returned
     * record. The spec is a name or nested-record shape matching the
     * `Model.queryData(name, fn)` registrations on the backend — the
     * frontend ships only these names; the SQL fragments stay server-
     * side. All resulting aliases are attached to the root record and
     * read back with `record.queryData(aliasName)`.
     * @param {string | Array<string | Record<string, ?>> | Record<string, ?>} spec
     * @returns {this}
     */
    queryData(spec: string | Array<string | Record<string, unknown>> | Record<string, unknown>): this;
    /**
     * Runs where.
     * @param {Record<string, ?>} conditions - Root-model where conditions.
     * @returns {this} - Query with merged where conditions.
     */
    where(conditions: Record<string, unknown>): this;
    /**
     * Runs scope.
     * @param {import("../utils/model-scope.js").ModelScopeDescriptor} scopeDescriptor - Scope descriptor.
     * @returns {this} - Scoped query.
     */
    scope(scopeDescriptor: import("../utils/model-scope.js").ModelScopeDescriptor): this;
    /**
     * Runs ransack.
     * @param {Record<string, ?>} params - Ransack-style params hash. Supports `s` key for sorting (e.g., `{s: "name asc"}`).
     * @returns {this} - Query with Ransack filters and sort applied.
     */
    ransack(params: Record<string, unknown>): this;
    /**
     * Runs select with required root attributes.
     * @param {string[]} [requiredAttributes] - Extra required attributes for the root model.
     * @returns {Record<string, string[]>} - Select map with required root attributes merged when root select exists.
     */
    selectWithRequiredRootAttributes(requiredAttributes?: string[]): Record<string, string[]>;
    /**
     * Runs preload.
     * @param {import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>} preload - Preload to merge.
     * @returns {this} - Query with merged preloads.
     */
    preload(preload: import("../database/query/index.js").NestedPreloadRecord | string | Array<string | import("../database/query/index.js").NestedPreloadRecord>): this;
    /**
     * Runs select.
     * @param {Record<string, string[] | string> | string | string[]} select - Model-aware attribute select map or root-model shorthand.
     * @returns {this} - Query with merged selected attributes.
     */
    select(select: Record<string, string[] | string> | string | string[]): this;
    /**
     * Like `select(...)`, but keeps the default serialized attributes and loads
     * the given extras in addition (for example attributes declared
     * `selectedByDefault: false`). Keyed by model name, with root-model shorthand.
     * @param {Record<string, string[] | string> | string | string[]} select - Extra attributes to load, keyed by model name or root-model shorthand.
     * @returns {this} - Query with merged extra selected attributes.
     */
    selectsExtra(select: Record<string, string[] | string> | string | string[]): this;
    /**
     * Runs joins.
     * @param {Record<string, ?> | Array<Record<string, ?>>} joins - Relationship descriptor joins.
     * @returns {this} - Query with merged joins.
     */
    joins(joins: Record<string, unknown> | Array<Record<string, unknown>>): this;
    /**
     * Returns the search result.
     * @param {string[]} path - Relationship path.
     * @param {string} column - Column or attribute name.
     * @param {"eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq" | ">" | ">=" | "<" | "<="} operator - Search operator.
     * @param {?} value - Search value.
     * @returns {this} - Query with appended search.
     */
    search(path: string[], column: string, operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq" | ">" | ">=" | "<" | "<=", value: unknown): this;
    /**
     * Runs sort.
     * @param {string | string[] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} sort - Sort definition(s).
     * @returns {this} - Query with appended sort definitions.
     */
    sort(sort: string | string[] | [string, string] | Array<[string, string]> | Record<string, unknown> | Array<Record<string, unknown>>): this;
    /**
     * Runs order.
     * @param {string | string[] | [string, string] | Array<[string, string]> | Record<string, ?> | Array<Record<string, ?>>} order - Order definition(s).
     * @returns {this} - Query with appended sort definitions.
     */
    order(order: string | string[] | [string, string] | Array<[string, string]> | Record<string, unknown> | Array<Record<string, unknown>>): this;
    /**
     * Runs group.
     * @param {string | string[] | Record<string, ?> | Array<Record<string, ?>>} group - Group definition(s).
     * @returns {this} - Query with appended group definitions.
     */
    group(group: string | string[] | Record<string, unknown> | Array<Record<string, unknown>>): this;
    /**
     * Runs distinct.
     * @param {boolean} [value] - Whether to request distinct rows.
     * @returns {this} - Query with distinct flag.
     */
    distinct(value?: boolean): this;
    /**
     * Returns the limit result.
     * @param {number} value - Maximum number of records.
     * @returns {this} - Query with limit.
     */
    limit(value: number): this;
    /**
     * Runs offset.
     * @param {number} value - Number of records to skip.
     * @returns {this} - Query with offset.
     */
    offset(value: number): this;
    /**
     * Runs page.
     * @param {number} pageNumber - 1-based page number.
     * @returns {this} - Query with page applied.
     */
    page(pageNumber: number): this;
    /**
     * Runs per page.
     * @param {number} perPage - Page size.
     * @returns {this} - Query with per-page applied.
     */
    perPage(perPage: number): this;
    /**
     * Runs clone.
     * @returns {FrontendModelQuery<T>} - Cloned query instance.
     */
    clone(): FrontendModelQuery<T>;
    /**
     * Runs get model class.
     * @returns {T} - Root model class.
     */
    getModelClass(): T;
    /**
     * Runs preload payload.
     * @returns {Record<string, ?>} - Payload preload hash when present.
     */
    preloadPayload(): Record<string, unknown>;
    /**
     * Runs with count payload.
     * @returns {Record<string, ?>} - Payload withCount array when present.
     */
    withCountPayload(): Record<string, unknown>;
    /**
     * Runs abilities payload.
     * @returns {Record<string, ?>} - Payload abilities array when present.
     */
    abilitiesPayload(): Record<string, unknown>;
    /**
     * Runs query data payload.
     * @returns {Record<string, ?>} - Payload queryData spec when present.
     */
    queryDataPayload(): Record<string, unknown>;
    /**
     * Runs select payload.
     * @param {string[]} [requiredAttributes] - Extra required attributes for root model selection.
     * @returns {Record<string, ?>} - Payload select hash when present.
     */
    selectPayload(requiredAttributes?: string[]): Record<string, unknown>;
    /**
     * Runs selects extra payload.
     * @returns {Record<string, ?>} - Payload selectsExtra hash when present.
     */
    selectsExtraPayload(): Record<string, unknown>;
    /**
     * Runs search payload.
     * @returns {Record<string, ?>} - Payload searches array when present.
     */
    searchPayload(): Record<string, unknown>;
    /**
     * Runs ransack payload.
     * @returns {Record<string, ?>} - Payload ransack hash when present.
     */
    ransackPayload(): Record<string, unknown>;
    /**
     * Runs joins payload.
     * @returns {Record<string, ?>} - Payload joins hash when present.
     */
    joinsPayload(): Record<string, unknown>;
    /**
     * Runs sort payload.
     * @returns {Record<string, ?>} - Payload sort array when present.
     */
    sortPayload(): Record<string, unknown>;
    /**
     * Runs group payload.
     * @returns {Record<string, ?>} - Payload group array when present.
     */
    groupPayload(): Record<string, unknown>;
    /**
     * Runs distinct payload.
     * @returns {Record<string, ?>} - Payload distinct flag when enabled.
     */
    distinctPayload(): Record<string, unknown>;
    /**
     * Runs where payload.
     * @returns {Record<string, ?>} - Payload where hash when present.
     */
    wherePayload(): Record<string, unknown>;
    /**
     * Runs pagination payload.
     * @returns {Record<string, ?>} - Payload pagination params when present.
     */
    paginationPayload(): Record<string, unknown>;
    /**
     * Runs assert event query supported.
     * @returns {void}
     * @throws {Error} When the query contains list-only options that cannot filter a single lifecycle event.
     */
    assertEventQuerySupported(): void;
    /**
     * Runs event projection payload.
     * @returns {FrontendModelProjectionPayload} - Projection payload used when serializing lifecycle events.
     */
    eventProjectionPayload(): FrontendModelProjectionPayload;
    /**
     * Runs event filter payload.
     * @returns {FrontendModelEventFilterPayload | null} - Query pieces used to match lifecycle events.
     */
    eventFilterPayload(): FrontendModelEventFilterPayload | null;
    /**
     * Returns the eventOptionsPayload result.
     * @returns {FrontendModelEventOptionsPayload} - Combined event filter and projection payload.
     */
    eventOptionsPayload(): FrontendModelEventOptionsPayload;
    /**
     * Runs load.
     * @returns {Promise<InstanceType<T>[]>} - Loaded model instances.
     */
    load(): Promise<InstanceType<T>[]>;
    /**
     * Runs to array.
     * @returns {Promise<InstanceType<T>[]>} - Loaded model instances.
     */
    toArray(): Promise<InstanceType<T>[]>;
    /**
     * Runs count.
     * @returns {Promise<number>} - Number of loaded model instances.
     */
    count(): Promise<number>;
    /**
     * Runs first.
     * @returns {Promise<InstanceType<T> | null>} - First model matching query.
     */
    first(): Promise<InstanceType<T> | null>;
    /**
     * Runs last.
     * @returns {Promise<InstanceType<T> | null>} - Last model matching query.
     */
    last(): Promise<InstanceType<T> | null>;
    /**
     * Runs pluck.
     * @param {...(string | string[] | Record<string, ?> | Array<Record<string, ?>>)} columns - Pluck definition(s).
     * @returns {Promise<Array<?>>} - Plucked values.
     */
    pluck(...columns: (string | string[] | Record<string, unknown> | Array<Record<string, unknown>>)[]): Promise<Array<unknown>>;
    /**
     * Runs find.
     * @param {number | string} id - Record id.
     * @returns {Promise<InstanceType<T>>} - Found model.
     */
    find(id: number | string): Promise<InstanceType<T>>;
    /**
     * Runs find by.
     * @param {Record<string, ?>} conditions - Conditions.
     * @returns {Promise<InstanceType<T> | null>} - Found model or null.
     */
    findBy(conditions: Record<string, unknown>): Promise<InstanceType<T> | null>;
    /**
     * Runs find by or fail.
     * @param {Record<string, ?>} conditions - Conditions.
     * @returns {Promise<InstanceType<T>>} - Found model.
     */
    findByOrFail(conditions: Record<string, unknown>): Promise<InstanceType<T>>;
    /**
     * Runs find or initialize by.
     * @param {Record<string, ?>} conditions - Conditions.
     * @returns {Promise<InstanceType<T>>} - Existing or initialized model.
     */
    findOrInitializeBy(conditions: Record<string, unknown>): Promise<InstanceType<T>>;
    /**
     * Runs find or create by.
     * @param {Record<string, ?>} conditions - Conditions.
     * @param {(model: InstanceType<T>) => Promise<void> | void} [callback] - Optional callback before save.
     * @returns {Promise<InstanceType<T>>} - Existing or newly created model.
     */
    findOrCreateBy(conditions: Record<string, unknown>, callback?: (model: InstanceType<T>) => Promise<void> | void): Promise<InstanceType<T>>;
    /**
     * Runs validated structured conditions.
     * @param {Record<string, ?>} conditions - Candidate structured conditions.
     * @returns {Record<string, ?>} - Validated conditions.
     */
    validatedStructuredConditions(conditions: Record<string, unknown>): Record<string, unknown>;
}
/**
 * FrontendModelSearch type.
 */
export type FrontendModelSearch = {
    /**
     * - Attribute name to search.
     */
    column: string;
    /**
     * - Search operator.
     */
    operator: "eq" | "like" | "notEq" | "gt" | "gteq" | "lt" | "lteq";
    /**
     * - Relationship path from root model.
     */
    path: string[];
    /**
     * - Search value.
     */
    value: unknown;
};
/**
 * FrontendModelTransportValue type.
 */
export type FrontendModelTransportValue = null | boolean | number | string | object;
/**
 * Defines this typedef.
 */
export type FrontendModelWithCountPayloadEntry = {
    attributeName: string;
    relationshipName: string;
    where?: Record<string, FrontendModelTransportValue>;
};
/**
 * Defines this typedef.
 */
export type FrontendModelAbilitiesPayloadEntry = {
    modelName: string;
    actions: string[];
};
/**
 * FrontendModelProjectionOptions type.
 */
export type FrontendModelProjectionOptions = {
    /**
     * - Model-aware attribute select map or root-model shorthand.
     */
    select?: string | string[] | Record<string, string | string[]> | undefined;
    /**
     * - Extra attributes to load in addition to the defaults, keyed by model name or root-model shorthand.
     */
    selectsExtra?: string | string[] | Record<string, string | string[]> | undefined;
    /**
     * - Relationship preload tree.
     */
    preload?: string | import("../database/query/index.js").NestedPreloadRecord | (string | import("../database/query/index.js").NestedPreloadRecord)[] | undefined;
    /**
     * - Association count spec.
     */
    withCount?: string | string[] | Record<string, boolean | {
        relationship?: string;
        where?: Record<string, FrontendModelTransportValue>;
    }> | undefined;
    /**
     * - Ability actions to compute per record.
     */
    abilities?: string[] | Record<string, string[]> | undefined;
    /**
     * - Backend query data names/spec.
     */
    queryData?: string | Record<string, FrontendModelTransportValue> | (string | Record<string, FrontendModelTransportValue>)[] | undefined;
};
/**
 * Defines this typedef.
 */
export type FrontendModelEventOptionsObject = FrontendModelProjectionOptions & {
    query?: FrontendModelQuery<typeof import("./base.js").default>;
};
/**
 * FrontendModelEventOptions type.
 */
export type FrontendModelEventOptions = FrontendModelEventOptionsObject | FrontendModelQuery<typeof import("./base.js").default>;
/**
 * FrontendModelProjectionPayload type.
 */
export type FrontendModelProjectionPayload = {
    /**
     * - Normalized select map.
     */
    select?: Record<string, string[]> | undefined;
    /**
     * - Normalized extra select map.
     */
    selectsExtra?: Record<string, string[]> | undefined;
    /**
     * - Normalized preload tree.
     */
    preload?: import("../database/query/index.js").NestedPreloadRecord | undefined;
    /**
     * - Normalized count specs.
     */
    withCount?: FrontendModelWithCountPayloadEntry[] | undefined;
    /**
     * - Normalized ability specs.
     */
    abilities?: FrontendModelAbilitiesPayloadEntry[] | undefined;
    /**
     * - Normalized queryData spec.
     */
    queryData?: FrontendModelTransportValue | undefined;
};
/**
 * FrontendModelEventFilterPayload type.
 */
export type FrontendModelEventFilterPayload = {
    /**
     * - Relationship joins needed for matching.
     */
    joins?: Record<string, FrontendModelTransportValue> | undefined;
    /**
     * - Search predicates needed for matching.
     */
    searches?: FrontendModelSearch[] | undefined;
    /**
     * - Structured where predicates needed for matching.
     */
    where?: Record<string, FrontendModelTransportValue> | undefined;
};
/**
 * Defines this typedef.
 */
export type FrontendModelEventFilterPayloadEntry = FrontendModelEventFilterPayload & {
    key: string;
};
/**
 * FrontendModelEventOptionsPayload type.
 */
export type FrontendModelEventOptionsPayload = {
    /**
     * - Stable event filter key, or null when no filter is present.
     */
    eventFilterKey: string | null;
    /**
     * - Normalized event filter payload, or null when unfiltered.
     */
    eventFilterPayload: FrontendModelEventFilterPayload | null;
    /**
     * - Normalized event serialization projection payload.
     */
    projectionPayload: FrontendModelProjectionPayload;
};
/**
 * 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[];
};
//# sourceMappingURL=query.d.ts.map