import type { IDenormalizeDelegate, Schema, SchemaSimple } from '../interface.js';
import type { Denormalize, DenormalizeNullable, Normalize, NormalizeNullable } from '../normal.js';
import type { EntityFields } from './EntityFields.js';
type IsAny<T> = 0 extends 1 & T ? true : false;
/** Derives strict Args for LazyQuery from the inner schema S.
 *
 * - Entity: [EntityFields<U>] for queryKey delegation
 * - Collection (or schema with typed queryKey + key): inner schema's Args
 * - Everything else: [Normalize<S>] — pass the parent's raw normalized value
 */
export type LazySchemaArgs<S extends Schema> = S extends {
    createIfValid: any;
    pk: any;
    key: string;
    prototype: infer U;
} ? [
    EntityFields<U>
] : S extends ({
    queryKey(args: infer Args, ...rest: any): any;
    key: string;
}) ? IsAny<Args> extends true ? [
    Normalize<S>
] : Args : [Normalize<S>];
/**
 * Skips eager denormalization of a relationship field.
 * Raw normalized values (PKs/IDs) pass through unchanged.
 * Use `.query` with `useQuery` to resolve lazily.
 *
 * @see https://dataclient.io/rest/api/Lazy
 */
export default class Lazy<S extends Schema> implements SchemaSimple {
    schema: S;
    /**
     * @param {Schema} schema - The inner schema (e.g., [Building], Building, Collection)
     */
    constructor(schema: S);
    normalize(input: any, parent: any, key: any, delegate: any): any;
    denormalize(input: {}, _delegate: IDenormalizeDelegate): any;
    queryKey(_args: readonly any[], _unvisit: (...args: any) => any, _delegate: any): undefined;
    /** Queryable schema for use with useQuery() to resolve lazy relationships */
    get query(): LazyQuery<S>;
    private _query;
    _denormalizeNullable: (input: {}, delegate: IDenormalizeDelegate) => any;
    _normalizeNullable: () => NormalizeNullable<S>;
}
/**
 * Resolves lazy relationships via useQuery().
 *
 * queryKey delegates to inner schema's queryKey if available,
 * otherwise passes through args[0] (the raw normalized value).
 */
export declare class LazyQuery<S extends Schema, Args = LazySchemaArgs<S>> {
    schema: S;
    constructor(schema: S);
    denormalize(input: {}, delegate: IDenormalizeDelegate): Denormalize<S>;
    queryKey(args: Args, unvisit: (...args: any) => any, delegate: {
        getEntity: any;
        getIndex: any;
    }): any;
    _denormalizeNullable: (input: {}, delegate: IDenormalizeDelegate) => DenormalizeNullable<S>;
}
export {};
//# sourceMappingURL=Lazy.d.ts.map