import { z } from 'zod';
import { type JsonValue } from './common';
export declare const PageMemberSchema: z.ZodString;
export declare const PageValuePathSchema: z.ZodArray<z.ZodString>;
export declare const PageExpressionRootSchema: z.ZodEnum<{
    state: "state";
    model: "model";
    result: "result";
    bindings: "bindings";
    queries: "queries";
    scope: "scope";
    intent: "intent";
    actions: "actions";
}>;
export declare const PageOperatorSchema: z.ZodEnum<{
    string: "string";
    number: "number";
    max: "max";
    length: "length";
    concat: "concat";
    slice: "slice";
    entries: "entries";
    includes: "includes";
    trim: "trim";
    fixed: "fixed";
    add: "add";
    subtract: "subtract";
    multiply: "multiply";
    divide: "divide";
    min: "min";
    round: "round";
    equals: "equals";
    "not-equals": "not-equals";
    "less-than": "less-than";
    "less-or-equal": "less-or-equal";
    "greater-than": "greater-than";
    "greater-or-equal": "greater-or-equal";
    and: "and";
    or: "or";
    not: "not";
    coalesce: "coalesce";
    get: "get";
    "set-path": "set-path";
    merge: "merge";
    "from-entries": "from-entries";
    "array-concat": "array-concat";
    "number-format": "number-format";
    "encode-uri-component": "encode-uri-component";
}>;
export type PageExpression = {
    kind: 'literal';
    value: JsonValue;
} | {
    kind: 'read';
    root: z.infer<typeof PageExpressionRootSchema>;
    path: string[];
} | {
    kind: 'operator';
    operator: z.infer<typeof PageOperatorSchema>;
    arguments: PageExpression[];
} | {
    kind: 'conditional';
    condition: PageExpression;
    then: PageExpression;
    else: PageExpression;
} | {
    kind: 'object';
    fields: Record<string, PageExpression>;
} | {
    kind: 'array';
    items: PageExpression[];
} | {
    kind: 'map' | 'filter' | 'sum';
    source: PageExpression;
    value: PageExpression;
};
export declare const PAGE_EXPRESSION_LIMITS: Readonly<{
    depth: 32;
    nodes: 4096;
    operations: 20000;
    collection: 1000;
    bytes: 1048576;
}>;
export declare const assertPageValueBudget: (value: unknown) => void;
/** The input guard runs before recursive schema parsing, including direct Page parsing. */
export declare const PageExpressionSchema: z.ZodPipe<z.ZodUnknown, z.ZodType<PageExpression, unknown, z.core.$ZodTypeInternals<PageExpression, unknown>>>;
export declare const PagePropertyBindingSchema: z.ZodObject<{
    targetPath: z.ZodArray<z.ZodString>;
    expression: z.ZodPipe<z.ZodUnknown, z.ZodType<PageExpression, unknown, z.core.$ZodTypeInternals<PageExpression, unknown>>>;
    valueType: z.ZodOptional<z.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        object: "object";
        null: "null";
        array: "array";
    }>>;
}, z.core.$strict>;
export type PagePropertyBinding = z.infer<typeof PagePropertyBindingSchema>;
export declare const visitPageExpression: (expression: PageExpression, visit: (node: PageExpression) => void) => void;
export declare const collectPageExpressionReads: (expression: PageExpression) => Extract<PageExpression, {
    kind: 'read';
}>[];
/** Reads supplied by the caller, excluding lexically bound collection item/index reads. */
export declare const collectExternalPageExpressionReads: (expression: PageExpression) => Extract<PageExpression, {
    kind: 'read';
}>[];
//# sourceMappingURL=page-expression.d.ts.map