/**
 * The Postgres type catalog (Phase 0).
 *
 * Each Postgres type is described once, as a plain TS object that serves two
 * masters at the same time:
 *
 *   - runtime   → `oid` + `sqlType`: emit DDL and match columns against the live
 *                 database during a diff (Postgres speaks in OIDs, not names).
 *   - compile   → `tsType`: a *phantom* field carrying the corresponding TS type
 *                 so the shape can infer `number`/`string`/`Date`/... with zero
 *                 runtime cost. It is `undefined` at runtime.
 *
 * `tsLabel` is the runtime-visible string twin of `tsType` (e.g. "number"),
 * reserved for future codegen (edge validation / Zod) and debugging.
 */
/** Runtime-visible label of the TS type a column hydrates to. */
type TsLabel = "string" | "number" | "bigint" | "boolean" | "Date" | "Uint8Array" | "unknown";
/**
 * A single entry in the Postgres type catalog.
 *
 * @typeParam TName - the catalog key and discriminant (e.g. "int4").
 * @typeParam TTs   - the TS type a value of this column hydrates to.
 */
interface PgType<TName extends string = string, TTs = unknown> {
    /** Catalog key + discriminant. Matches the short Postgres type name. */
    readonly name: TName;
    /** Canonical SQL text emitted in DDL (e.g. "integer", "timestamp with time zone"). */
    readonly sqlType: string;
    /** Stable Postgres OID (from `pg_type`), the robust key for diffing. */
    readonly oid: number;
    /** Runtime-visible twin of `tsType`, for codegen/debug. */
    readonly tsLabel: TsLabel;
    /**
     * Phantom carrier of the TS type. Always `undefined` at runtime — read it
     * only at the type level via {@link Infer}.
     */
    readonly tsType: TTs;
}

/**
 * Column builder (Phase 1a; `hasDefault` added at the type level in Phase 2c).
 *
 * A `Column` wraps a {@link PgType} from the catalog and layers column-level
 * modifiers on top. It is **immutable**: every modifier returns a *new* column,
 * so type narrowing is correct and config never leaks between uses.
 *
 * Two facts are tracked at the type level:
 *   - **nullability** (`TNotNull`): changes the *read* type (`T` vs `T | null`).
 *   - **hasDefault** (`THasDefault`): changes the *insert* type — a notNull
 *     column with a default becomes optional on insert (the DB fills it).
 */

/** Runtime description of a column, consumed by the DDL layer. */
interface ColumnConfig {
    /** Stable field id (UUID) — survives rename. Normally born from `weave gen`; absent for hand-written, id-less fields. */
    readonly id?: string;
    /** The underlying catalog type. For arrays, the *element* type. */
    readonly pgType: PgType;
    /** Whether this is `type[]` rather than a scalar `type`. */
    readonly isArray: boolean;
    /** `NOT NULL` when true. */
    readonly notNull: boolean;
    /** Whether a default was declared. */
    readonly hasDefault: boolean;
    /** The declared default (literal value, or `[]` for arrays). Present iff `hasDefault`. */
    readonly default?: unknown;
    /** Single-column `UNIQUE`. */
    readonly unique: boolean;
    /** Single-column btree index. */
    readonly index: boolean;
}
/**
 * A column over data type `TData`.
 *
 * @typeParam TData       - the TS value type (e.g. `string`, `string[]`).
 * @typeParam TNotNull    - `true` once `.notNull()` (or an array default) applies.
 * @typeParam THasDefault - `true` once a default exists (`.default()` or array).
 */
declare class Column<TData, TNotNull extends boolean = false, THasDefault extends boolean = false> {
    readonly config: ColumnConfig;
    /** Phantom carrier so the compiler can recover the type params. No runtime field. */
    readonly _types: {
        data: TData;
        notNull: TNotNull;
        hasDefault: THasDefault;
    };
    constructor(config: ColumnConfig);
    /** Mark the column `NOT NULL` — narrows the read type from `T | null` to `T`. */
    notNull(): Column<TData, true, THasDefault>;
    /** Mark the column nullable — widens the read type back to `T | null`. */
    nullable(): Column<TData, false, THasDefault>;
    /** Declare a default value — makes the column optional on insert. */
    default(value: DefaultArg<TData>): Column<TData, TNotNull, true>;
    /** Add a single-column `UNIQUE`. */
    unique(): Column<TData, TNotNull, THasDefault>;
    /** Add a single-column index. */
    index(): Column<TData, TNotNull, THasDefault>;
    /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
    $id(id: string): Column<TData, TNotNull, THasDefault>;
}
/** Arg de `.default()`: o tipo da coluna — mais `number` p/ colunas backed por `bigint`
 *  (int8), pra `int8().default(0)` funcionar como int2/int4 (sem exigir `0n`). */
type DefaultArg<TData> = TData extends bigint ? number | bigint : TData;
/** The TS type a column reads as, accounting for nullability. */
type InferColumn<C> = C extends Column<infer TData, infer TNotNull, boolean> ? TNotNull extends true ? TData : TData | null : never;

type IsColumn$1<V> = V extends {
    _types: unknown;
} ? true : false;
type IsOwned$1<V> = V extends {
    kind: "owned";
} ? true : false;
type IsRefOne$1<V> = V extends {
    _phantom: {
        cardinality: "one";
    };
} ? true : false;
type IsRefMany$1<V> = V extends {
    _phantom: {
        cardinality: "many";
    };
} ? true : false;
type ColumnData<V> = V extends {
    _types: {
        data: infer D;
    };
} ? D : never;
type RefTargetShape$1<V> = V extends {
    _phantom: {
        target: Entity<string, infer TS>;
    };
} ? TS : never;
/** Orçamento de profundidade pra filtros aninhados (guarda contra ciclos). */
type WBudget = [unknown, unknown, unknown, unknown, unknown, unknown];
type WDrop<D extends unknown[]> = D extends [unknown, ...infer R] ? R : [];
/** Operadores só-de-string, somados quando o tipo do dado é `string`. */
type StringOps<P = never> = {
    like?: string | P;
    ilike?: string | P;
};
/** Operadores de comparação/pertinência pra uma coluna escalar de tipo `T`. */
type ScalarOps<T, P = never> = {
    eq?: T | null | P;
    ne?: T | null | P;
    gt?: T | P;
    gte?: T | P;
    lt?: T | P;
    lte?: T | P;
    in?: T[] | P;
    notIn?: T[] | P;
    isNull?: boolean;
} & ([T] extends [string] ? StringOps<P> : {});
/** Filtro de uma coluna escalar: um valor cru (atalho de `eq`) ou um objeto de operadores. */
type Filter<T, P = never> = T | P | ScalarOps<T, P>;
/** Operadores pra uma coluna de array escalar (`text[]`, `int4[]`, …). */
type ArrayFilter<E, P = never> = {
    has?: E | P;
    hasSome?: E[] | P;
    hasEvery?: E[] | P;
    isEmpty?: boolean;
    /** Algum elemento casa estes operadores escalares (o "any …" da GUI). */
    some?: ScalarOps<E, P>;
};
/** Filtro de uma coluna — operadores de array pra `type[]`, escalares senão. */
type ColumnFilter<V, P = never> = ColumnData<V> extends (infer E)[] ? ArrayFilter<E, P> : Filter<ColumnData<V>, P>;
/** Quantificadores sobre um relacionamento to-many (owned 1:N / reference N:N). */
type Quantifier<W> = {
    some?: W;
    every?: W;
    none?: W;
};
type WhereShape<TShape, D extends unknown[] = WBudget, P = never> = {
    id?: Filter<string, P>;
    createdAt?: Filter<Date, P>;
    updatedAt?: Filter<Date, P>;
    and?: WhereShape<TShape, D, P>[];
    or?: WhereShape<TShape, D, P>[];
    not?: WhereShape<TShape, D, P>;
} & (D extends [] ? {} : {
    [K in keyof TShape as IsColumn$1<TShape[K]> extends true ? K : never]?: ColumnFilter<TShape[K], P>;
} & {
    [K in keyof TShape as IsOwned$1<TShape[K]> extends true ? K : never]?: TShape[K] extends Owned<infer S, infer C> ? C extends "many" ? Quantifier<WhereShape<S, WDrop<D>, P>> : WhereShape<S, WDrop<D>, P> : never;
} & {
    [K in keyof TShape as IsRefOne$1<TShape[K]> extends true ? K : never]?: WhereShape<RefTargetShape$1<TShape[K]>, WDrop<D>, P>;
} & {
    [K in keyof TShape as IsRefOne$1<TShape[K]> extends true ? `${K & string}Id` : never]?: Filter<string, P>;
} & {
    [K in keyof TShape as IsRefMany$1<TShape[K]> extends true ? K : never]?: Quantifier<WhereShape<RefTargetShape$1<TShape[K]>, WDrop<D>, P>>;
});
/**
 * Filtro sobre uma entidade. Operadores escalares (`gt`/`in`/`ilike`/…), de array
 * (`has`/`hasSome`/…), lógicos `and`/`or`/`not`, e filtro **aninhado** sobre
 * `owned`/`reference` com quantificadores `some`/`every`/`none`.
 */
type WhereInput<E> = E extends Entity<string, infer TShape> ? WhereShape<TShape> : never;
/**
 * Igual ao `WhereInput`, mas cada folha escalar também aceita `{ param: "x" }` — o
 * filtro de linhas de um SCOPE, resolvido no request-time. Literal e param se misturam
 * livremente (`{ and: [{ company: { eq: { param: "co" } } }, { active: { eq: true } }] }`).
 * (Obs.: `not` não é suportado no storage do scope — usar `not` falha no push.)
 */
type ScopeWhereInput<E> = E extends Entity<string, infer TShape> ? WhereShape<TShape, WBudget, {
    param: string;
}> : never;
/** Orçamento de profundidade pro dot-path (guarda contra ciclos). */
type PBudget = [unknown, unknown, unknown, unknown, unknown];
type PathOf<TShape, D extends unknown[] = PBudget> = D extends [] ? never : {
    [K in keyof TShape & string]: IsColumn$1<TShape[K]> extends true ? K : IsOwned$1<TShape[K]> extends true ? TShape[K] extends Owned<infer S, OwnedCardinality> ? K | `${K}.${PathOf<S, WDrop<D>> & string}` : K : IsRefOne$1<TShape[K]> extends true ? K | `${K}.${PathOf<RefTargetShape$1<TShape[K]>, WDrop<D>> & string}` : IsRefMany$1<TShape[K]> extends true ? K | `${K}.${PathOf<RefTargetShape$1<TShape[K]>, WDrop<D>> & string}` : never;
}[keyof TShape & string];
/**
 * Dot-path de campo de uma entity, pra a PROJEÇÃO de um scope (`fields.include/exclude`).
 * Folha (`"whatsapp"`), path aninhado (`"summaryForTheManager.expectedRoi"`) ou uma
 * subárvore inteira (`"customer"`). Typo/rename viram erro de compilação.
 */
type FieldPath<E> = E extends Entity<string, infer TShape> ? PathOf<TShape> : never;
/**
 * Union dos NOMES de param (`{ param: "x" }`) em qualquer lugar de uma árvore — o where
 * de um scope. Anda por objetos e arrays; a folha `{ param: L }` rende o literal `L`.
 * Requer que os literais sejam preservados (o `scopeRule` usa `const` no config).
 */
type ExtractParams<T> = T extends {
    param: infer L;
} ? L extends string ? L : never : T extends readonly (infer U)[] ? ExtractParams<U> : T extends object ? {
    [K in keyof T]: ExtractParams<T[K]>;
}[keyof T] : never;
/** Direção de ordenação. */
type SortDir = "asc" | "desc";
type OrderByShape<TShape, D extends unknown[] = WBudget> = {
    id?: SortDir;
    createdAt?: SortDir;
    updatedAt?: SortDir;
} & (D extends [] ? {} : {
    [K in keyof TShape as IsColumn$1<TShape[K]> extends true ? K : never]?: SortDir;
} & {
    [K in keyof TShape as TShape[K] extends Owned<OwnedShape, "one"> ? K : never]?: TShape[K] extends Owned<infer S, "one"> ? OrderByShape<S, WDrop<D>> : never;
} & {
    [K in keyof TShape as IsRefOne$1<TShape[K]> extends true ? K : never]?: OrderByShape<RefTargetShape$1<TShape[K]>, WDrop<D>>;
});
/** Ordena pelo `id`, timestamps, colunas escalares, ou um caminho aninhado (owned 1:1 / reference N:1). */
type OrderByInput<E> = E extends Entity<string, infer TShape> ? OrderByShape<TShape> : never;

/** Marcador de op que o compilador do accumulate lê pra montar o upsert. */
type AccumulateOp = {
    readonly op: "inc";
    readonly by: number;
} | {
    readonly op: "max";
    readonly value: number;
} | {
    readonly op: "min";
    readonly value: number;
} | {
    readonly op: "setOnInsert";
    readonly value: unknown;
};
/** Incrementa (soma) — contador/soma monotônico. Default `+1`. */
declare const inc: (by?: number) => AccumulateOp;
/** Grava só na INSERÇÃO; no conflito preserva o valor existente (ex.: `ts` do bucket). */
declare const setOnInsert: (value: unknown) => AccumulateOp;
/** Entrada do `accumulate(key, ops)`: `key` = colunas do `ON CONFLICT` (o unique
 *  declarado); `ops` = `campo → op`. */
interface AccumulateInput {
    readonly key: Record<string, unknown>;
    readonly ops: Record<string, AccumulateOp>;
}

/** Opções comuns a todo acumulador. `where` recorta a métrica → `agg(…) FILTER (WHERE …)`. */
interface AggOpts {
    readonly where?: Record<string, unknown>;
}
/** Acumulador: marcador que o compilador lê. `count()` não tem campo; o resto tem. */
type Accumulator = {
    readonly agg: "count";
    readonly where?: Record<string, unknown>;
} | {
    readonly agg: "sum" | "avg" | "min" | "max" | "distinct";
    readonly field: string;
    readonly where?: Record<string, unknown>;
} | {
    readonly agg: "percentile";
    readonly field: string;
    readonly p: number;
    readonly where?: Record<string, unknown>;
} | {
    readonly agg: "histogram";
    readonly field: string;
    readonly bounds: number[];
    readonly where?: Record<string, unknown>;
} | {
    readonly agg: "first";
    readonly field: string;
    readonly where?: Record<string, unknown>;
};
declare const count: (opts?: AggOpts) => Accumulator;
declare const sum: (field: string, opts?: AggOpts) => Accumulator;
declare const avg: (field: string, opts?: AggOpts) => Accumulator;
declare function min(field: string, opts?: AggOpts): Accumulator;
declare function min(value: number): AccumulateOp;
declare function max(field: string, opts?: AggOpts): Accumulator;
declare function max(value: number): AccumulateOp;
/** Distintos EXATOS (`count(distinct …)`) — tier recente. */
declare const distinct: (field: string, opts?: AggOpts) => Accumulator;
/**
 * One representative value of `field` per group — `(array_agg(field ORDER BY created_at))[1]`.
 * Deterministic (ordered by the element's `created_at`). Meant for metadata that is constant
 * within a group (e.g. under `unnest`, the description/weight tied to the group key): `first`
 * just picks the representative. Not a running-order pick — it's the earliest-created member.
 */
declare const first: (field: string, opts?: AggOpts) => Accumulator;
/** Percentil EXATO (`percentile_cont`) sobre escalar cru. `p` é fração 0..1 (p95 → 0.95). */
declare const percentile: (field: string, p: number, opts?: AggOpts) => Accumulator;
/**
 * Contagem por balde sobre escalar cru (as "barras" de latência). `bounds`
 * ESTRITAMENTE crescente com N fronteiras → **N+1 baldes**: `< b0`, `[b0,b1)`, …,
 * `>= b_{N-1}` (o último é o overflow, +∞). Devolve o array de contagens como UM valor.
 */
declare const histogram: (field: string, bounds: number[], opts?: AggOpts) => Accumulator;
/** Expressão de grupo por tempo — trunca `field` em baldes de `interval` (epoch/UTC). */
type GroupExpr = {
    readonly timeBucket: {
        readonly field: string;
        readonly interval: string;
    };
};
declare const timeBucket: (field: string, interval: string) => GroupExpr;
/**
 * Operando de uma expressão aritmética: **nome de um alias do select** (`"errors"`),
 * um **número** literal, um **acumulador inline** (`count(...)`), ou outra `Expr`.
 */
type ExprOperand = string | number | Accumulator | Expr;
/** Expressão aritmética sobre agregados (Decisão 5/8). Vale em `orderBy`/`having`. */
interface Expr {
    readonly op: "div" | "mul" | "add" | "sub";
    readonly left: ExprOperand;
    readonly right: ExprOperand;
}
/** `a / b` — com `nullif(b,0)` (divisão-por-zero → null) e cast numérico (sem trunc inteiro). */
declare const div: (left: ExprOperand, right: ExprOperand) => Expr;
declare const mul: (left: ExprOperand, right: ExprOperand) => Expr;
declare const add: (left: ExprOperand, right: ExprOperand) => Expr;
declare const sub: (left: ExprOperand, right: ExprOperand) => Expr;
/**
 * Uma faceta: sub-agregação independente que RODA SOB O MESMO `where` do pai. É o
 * `aggregate` sem `where`/`facets` (herda o do pai) e com `limit` (top-N por faceta —
 * pressupõe `orderBy`). Alimenta o caso dashboard: vários breakdowns numa passada.
 */
interface FacetInput<E extends Entity<string, ShapeRecord>> {
    groupBy?: string[] | Record<string, string | GroupExpr>;
    select: Record<string, Accumulator | Expr>;
    having?: Record<string, unknown>;
    orderBy?: Record<string, SortDir>;
    limit?: number;
}
/**
 * Entrada do `aggregate`. `groupBy`: array de campos (chaves homônimas) OU mapa
 * `alias → campo | expr`. `select`: `alias → acumulador`. `having`: filtro sobre os
 * ALIASES do select (agregados) → `HAVING`. `orderBy`: por alias do select OU chave
 * de grupo. `page`/`perPage`: top-N paginado (pressupõe `orderBy`). `facets`: mapa de
 * sub-agregações independentes (breakdowns) sob o mesmo `where`. `where` é o mesmo
 * `WhereInput` do find (filtra ANTES de agrupar).
 */
interface AggregateInput<E extends Entity<string, ShapeRecord>> {
    where?: WhereInput<E>;
    /**
     * Unnest one `owned` list before grouping — the aggregate then runs over the list's
     * ELEMENTS (like Mongo's `$unwind`), one row per element. A dot-path to the array
     * (`"managerResult.anchors"`); the `groupBy`/accumulator `field`/FILTER paths then
     * address the element's fields (`"managerResult.anchors.name"`). `where` still filters
     * the PARENT rows; the accumulators' `{ where }` filter the elements. Counting parents
     * under `unnest` needs `distinct("id")` (the parent id repeats per element).
     */
    unnest?: string;
    groupBy?: string[] | Record<string, string | GroupExpr>;
    select: Record<string, Accumulator | Expr>;
    having?: Record<string, unknown>;
    orderBy?: Record<string, SortDir>;
    page?: number;
    perPage?: number;
    facets?: Record<string, FacetInput<E>>;
}
/**
 * Uma linha agregada: chaves de grupo + aliases do select. Tipagem precisa do
 * valor de cada alias (number para count/sum, tipo da coluna para a chave) é
 * fast-follow — o esqueleto devolve valores frouxos.
 */
type AggregateRow = Record<string, unknown>;
/**
 * Saída do `aggregate`, auto-ajustada ao input (igual o `expand`): sem `facets` no
 * input → `AggregateRow[]` puro; COM `facets` → `{ rows, facets: { <nome>: linhas } }`.
 * Assim o call-site que não pede breakdown não paga o embrulho.
 */
type AggregateOutput<I> = I extends {
    facets: infer F;
} ? {
    rows: AggregateRow[];
    facets: {
        [K in keyof F]: AggregateRow[];
    };
} : AggregateRow[];

/**
 * Entity declaration + inference.
 *
 * `defineEntity` captures the user's shape and, conceptually, owns three managed
 * system columns every (sub-)entity gets: `id` (uuid PK), `createdAt`,
 * `updatedAt`. Inference produces three views of a shape:
 *
 *   - {@link InferRead}   — the read object, parameterized by an `expand` map.
 *                           `owned` nests automatically; a `reference` surfaces
 *                           as `<field>Id` always, plus `<field>` when expanded.
 *   - {@link InferEntity} — `InferRead` with no expand (the default read shape).
 *   - {@link InferInsert} — the write object: notNull-without-default columns are
 *                           required, references are set via `<field>Id`.
 */

/** A record of named fields — columns, owned relationships, and/or references. */
type ShapeRecord = Record<string, Column<unknown, boolean, boolean> | AnyOwned | AnyReference>;
/** The managed system columns every (sub-)entity carries. */
interface SystemColumns {
    id: string;
    createdAt: Date;
    updatedAt: Date;
}
/** Flatten an intersection into a single object literal for readable hovers. */
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
/**
 * Constraints/índices no nível da ENTIDADE (multi-coluna). Cada grupo é uma lista
 * de nomes de campo: coluna → sua coluna; reference N:1 → a coluna FK `<campo>_id`.
 * (Owned e reference N:N não entram — não são colunas da tabela raiz.)
 */
interface EntityOptions {
    /** Grupos de UNIQUE composto (alvo de `ON CONFLICT` / chave de rollup). */
    readonly unique?: string[][];
    /** Grupos de índice composto (não-único). */
    readonly index?: string[][];
    /**
     * Particiona a tabela por tempo (RANGE nativo). `timeBucket(field, interval)` — o
     * campo tem que ser um `timestamptz().notNull()`. Torna a tabela **append-only**
     * (a PK passa a ser `(id, <field>)`). Genérico: qualquer série-temporal de volume.
     */
    readonly partitionBy?: GroupExpr;
    /** Retenção da partição (ex.: `"30d"`): partições cujo topo já passou são **dropadas**. */
    readonly retention?: string;
}
/** A declared entity: a table name plus its shape (+ constraints de entidade). */
interface Entity<TName extends string, TShape extends ShapeRecord> {
    readonly name: TName;
    readonly columns: TShape;
    readonly options?: EntityOptions;
}
type IsColumn<V> = V extends {
    _types: unknown;
} ? true : false;
type IsOwned<V> = V extends {
    kind: "owned";
} ? true : false;
type IsReference<V> = V extends {
    kind: "reference";
} ? true : false;
type IsRefOne<V> = IsReference<V> extends true ? (RefCard<V> extends "one" ? true : false) : false;
type IsRefMany<V> = IsReference<V> extends true ? (RefCard<V> extends "many" ? true : false) : false;
type RefTargetShape<V> = V extends {
    _phantom: {
        target: Entity<string, infer TS>;
    };
} ? TS : never;
type RefNotNull<V> = V extends {
    _phantom: {
        notNull: infer NN;
    };
} ? NN : false;
type RefCard<V> = V extends {
    _phantom: {
        cardinality: infer C;
    };
} ? C : "one";
/** Recursion-depth budget for cyclic schemas (caps nested expand types). */
type Budget = [unknown, unknown, unknown, unknown, unknown, unknown];
type Drop<D extends unknown[]> = D extends [unknown, ...infer R] ? R : [];
/** The sub-expand map for key `K` (or `{}` when absent / `true`). */
type ExpandFor<X, K extends PropertyKey> = K extends keyof X ? X[K] extends true ? {} : X[K] : {};
type ReadBody<TShape, X> = {
    [K in keyof TShape as IsColumn<TShape[K]> extends true ? K : never]: InferColumn<TShape[K]>;
} & {
    [K in keyof TShape as IsOwned<TShape[K]> extends true ? K : never]: TShape[K] extends Owned<infer S, infer C> ? C extends "many" ? Prettify<ReadShape<S, ExpandFor<X, K>>>[] : Prettify<ReadShape<S, ExpandFor<X, K>>> : never;
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? `${K & string}Id` : never]: RefNotNull<TShape[K]> extends true ? string : string | null;
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? K extends keyof X ? K : never : never]: RefNotNull<TShape[K]> extends true ? Prettify<ReadShape<RefTargetShape<TShape[K]>, ExpandFor<X, K>>> : Prettify<ReadShape<RefTargetShape<TShape[K]>, ExpandFor<X, K>>> | null;
} & {
    [K in keyof TShape as IsRefMany<TShape[K]> extends true ? K extends keyof X ? K : never : never]: Prettify<ReadShape<RefTargetShape<TShape[K]>, ExpandFor<X, K>>>[];
};
type ReadShape<TShape, X> = Pick<SystemColumns, "id"> & ReadBody<TShape, X> & Pick<SystemColumns, "createdAt" | "updatedAt">;
/** The read object for an entity, given an `expand` map `X`. */
type InferRead<E, X> = E extends Entity<string, infer TShape> ? Prettify<ReadShape<TShape, X>> : never;
/** The default read object (no expand). */
type InferEntity<E> = InferRead<E, {}>;
type ExpandShape<TShape, D extends unknown[] = Budget> = D extends [] ? {} : {
    [K in keyof TShape as IsReference<TShape[K]> extends true ? K : IsOwned<TShape[K]> extends true ? K : never]?: IsReference<TShape[K]> extends true ? true | ExpandShape<RefTargetShape<TShape[K]>, Drop<D>> : TShape[K] extends Owned<infer S, OwnedCardinality> ? ExpandShape<S, Drop<D>> : never;
};
/** The shape of the `expand` option for an entity. */
type ExpandInput<E> = E extends Entity<string, infer TShape> ? ExpandShape<TShape> : never;
/** Tipo de ESCRITA de uma coluna: o data-type, mais `number` p/ colunas `bigint` (int8).
 *  Motivo: JSON não carrega `bigint`, então o valor de escrita trafega como `number`
 *  (o SDK coage `bigint→number` antes de serializar). Espelha o `.default()` do int8. */
type WriteData<TData> = TData extends bigint ? number | bigint : TData;
type InsertField<V> = IsColumn<V> extends true ? V extends Column<infer TData, infer NN, boolean> ? NN extends true ? WriteData<TData> : WriteData<TData> | null : never : IsOwned<V> extends true ? V extends Owned<infer S, infer C> ? C extends "many" ? InsertOwned<S>[] : InsertOwned<S> : never : never;
/** A column is required on insert only if it is `notNull` AND has no default. */
type RequiredColumn<V> = V extends {
    _types: {
        notNull: true;
        hasDefault: false;
    };
} ? true : false;
type InsertBody<TShape> = Prettify<{
    [K in keyof TShape as IsColumn<TShape[K]> extends true ? RequiredColumn<TShape[K]> extends true ? K : never : never]: InsertField<TShape[K]>;
} & {
    [K in keyof TShape as IsColumn<TShape[K]> extends true ? RequiredColumn<TShape[K]> extends true ? never : K : never]?: InsertField<TShape[K]>;
} & {
    [K in keyof TShape as IsOwned<TShape[K]> extends true ? K : never]?: InsertField<TShape[K]>;
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? RefNotNull<TShape[K]> extends true ? `${K & string}Id` : never : never]: string;
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? RefNotNull<TShape[K]> extends true ? never : `${K & string}Id` : never]?: string | null;
} & {
    [K in keyof TShape as IsRefMany<TShape[K]> extends true ? `${K & string}Ids` : never]?: string[];
}>;
type InsertOwned<S extends OwnedShape> = Prettify<{
    id?: string;
} & InsertBody<S>>;
/** The object accepted by `save`: optional id (upsert), body, no managed timestamps. */
type InferInsert<E> = E extends Entity<string, infer TShape> ? Prettify<{
    id?: string;
} & InsertBody<TShape>> : never;
type SelectShape<TShape, D extends unknown[] = Budget> = {
    id?: true;
    createdAt?: true;
    updatedAt?: true;
} & {
    [K in keyof TShape as IsColumn<TShape[K]> extends true ? K : never]?: true;
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? `${K & string}Id` : never]?: true;
} & (D extends [] ? {} : {
    [K in keyof TShape as IsOwned<TShape[K]> extends true ? K : never]?: true | (TShape[K] extends Owned<infer S, OwnedCardinality> ? SelectShape<S, Drop<D>> : never);
} & {
    [K in keyof TShape as IsRefOne<TShape[K]> extends true ? K : IsRefMany<TShape[K]> extends true ? K : never]?: true | SelectShape<RefTargetShape<TShape[K]>, Drop<D>>;
});
/** The shape of the `select` option for an entity. */
type SelectInput<E> = E extends Entity<string, infer TShape> ? SelectShape<TShape> : never;
/** Full read of a sub-shape (all fields, references as ids) — used by `true`. */
type FullRead<TShape> = Prettify<ReadShape<TShape, {}>>;
type SelectSub<SubShape, Sel> = Sel extends true ? FullRead<SubShape> : SelectResultShape<SubShape, Sel>;
type SelectFieldType<TShape, K, Sel> = K extends "id" ? string : K extends "createdAt" | "updatedAt" ? Date : K extends keyof TShape ? IsColumn<TShape[K]> extends true ? InferColumn<TShape[K]> : TShape[K] extends Owned<infer S, infer C> ? C extends "many" ? SelectSub<S, Sel>[] : SelectSub<S, Sel> : IsRefOne<TShape[K]> extends true ? RefNotNull<TShape[K]> extends true ? SelectSub<RefTargetShape<TShape[K]>, Sel> : SelectSub<RefTargetShape<TShape[K]>, Sel> | null : IsRefMany<TShape[K]> extends true ? SelectSub<RefTargetShape<TShape[K]>, Sel>[] : never : K extends `${infer F}Id` ? F extends keyof TShape ? IsRefOne<TShape[F]> extends true ? RefNotNull<TShape[F]> extends true ? string : string | null : never : never : never;
type SelectResultShape<TShape, S> = Prettify<{
    id: string;
} & {
    -readonly [K in keyof S]: SelectFieldType<TShape, K, S[K]>;
}>;
/** The pruned read object for an entity, given a `select` map `S`. */
type InferSelect<E, S> = E extends Entity<string, infer TShape> ? SelectResultShape<TShape, S> : never;
/** Declare an entity (a first-class table). */
declare function defineEntity<TName extends string, TShape extends ShapeRecord>(name: TName, columns: TShape, options?: EntityOptions): Entity<TName, TShape>;

/**
 * `reference` relationship — association (Phases 3 & 4).
 *
 * The target is an **independent** entity (its own table), possibly shared by
 * many. This side only **points and reads**: it never writes the target table.
 *
 *   - `reference(city)`         → N:1. FK column `city_id` (no cascade).
 *                                 Reads `cityId` always, `city` on expand.
 *   - `reference(array(city))`  → N:N. A join table (`user_cities`), composite
 *                                 PK, both FKs cascade the *link*. Reads nothing
 *                                 by default; `cities: City[]` on expand. Writes
 *                                 via `citiesIds: string[]` (replaces the set).
 */

type ReferenceCardinality = "one" | "many";
type AnyEntity = Entity<string, ShapeRecord>;
/**
 * Marcador de auto-referência: `reference(self())` / `reference(array(self()))`.
 * NÃO carrega a entity por valor — o alvo é resolvido pro nome da PRÓPRIA entity no
 * `toIR`. Isso destrava o self-ref sem o muro de inferência de `const` (o thunk
 * `() => users` referenciaria `users` no próprio initializer; o `self()` não).
 */
declare class SelfMarker {
    readonly kind: "self";
}
/** Alvo de uma reference em runtime: entity eager, thunk lazy (ciclo/self), ou `self()`. */
type RefTargetRaw = AnyEntity | (() => AnyEntity) | SelfMarker;
declare class Reference<TTarget extends Entity<string, ShapeRecord> = Entity<string, ShapeRecord>, TCard extends ReferenceCardinality = "one", TNotNull extends boolean = false> {
    /**
     * Alvo. TIPADO como entity (os consumidores do engine leem `.target.name/.columns`
     * pós-`fromIR`, onde é sempre entity real). Em RUNTIME, no caminho de definição do
     * client, pode carregar thunk/`self()` cru — resolvido só no `toIR`/revive. Nunca
     * chega ao engine cru (vira nome no IR).
     */
    readonly target: TTarget;
    readonly cardinality: TCard;
    readonly isNotNull: boolean;
    /** Stable field id (UUID) — survives rename. Normally emitted by `weave gen`. */
    readonly id?: string | undefined;
    readonly kind: "reference";
    /** Phantom carrier so the compiler can recover target/cardinality/nullability. */
    readonly _phantom: {
        target: TTarget;
        cardinality: TCard;
        notNull: TNotNull;
    };
    constructor(
    /**
     * Alvo. TIPADO como entity (os consumidores do engine leem `.target.name/.columns`
     * pós-`fromIR`, onde é sempre entity real). Em RUNTIME, no caminho de definição do
     * client, pode carregar thunk/`self()` cru — resolvido só no `toIR`/revive. Nunca
     * chega ao engine cru (vira nome no IR).
     */
    target: TTarget, cardinality: TCard, isNotNull: boolean, 
    /** Stable field id (UUID) — survives rename. Normally emitted by `weave gen`. */
    id?: string | undefined);
    /** Nome da entity-alvo, resolvendo thunk/self (`selfName` = nome de quem contém). */
    targetName(selfName: string): string;
    /** Make the FK `NOT NULL` (only meaningful for N:1). */
    notNull(): Reference<TTarget, TCard, true>;
    /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
    $id(id: string): Reference<TTarget, TCard, TNotNull>;
}
/** A reference of any target/cardinality/nullability. */
type AnyReference = Reference<Entity<string, ShapeRecord>, ReferenceCardinality, boolean>;
/** Marker produced by `array(entity)` / `array(() => entity)` / `array(self())` — N:N. */
declare class ReferenceArray<TTarget extends Entity<string, ShapeRecord>> {
    readonly target: RefTargetRaw;
    readonly kind: "reference_array";
    constructor(target: RefTargetRaw);
}
/** `self()` — alvo = a própria entity. Para self-ref (`reference(self())` ou N:N). */
declare function self(): SelfMarker;
/** Declare an N:1 reference to an independent entity (nullable by default). */
declare function reference<T extends Entity<string, ShapeRecord>>(target: T): Reference<T, "one", false>;
/**
 * N:1 lazy (thunk) — para ciclo mútuo entre entities: `reference(() => users)`.
 * Alvo FROUXO de propósito: capturar `typeof users` no phantom criaria um ciclo de
 * inferência de `const` (typeof company ↔ typeof users) que colapsa o TShape inteiro.
 * O `expand` desse campo vem frouxo (o FK id e as colunas irmãs continuam precisos).
 * Refs ACÍCLICOS usam o overload eager (`reference(x)`), que mantém o expand tipado.
 */
declare function reference(thunk: () => Entity<string, ShapeRecord>): Reference<Entity<string, ShapeRecord>, "one", false>;
/** N:1 self-ref: `reference(self())`. Alvo frouxo (a própria entity). */
declare function reference(marker: SelfMarker): Reference<Entity<string, ShapeRecord>, "one", false>;
/** Declare an N:N reference (from `array(entity)` / `array(() => entity)` / `array(self())`). */
declare function reference<T extends Entity<string, ShapeRecord>>(set: ReferenceArray<T>): Reference<T, "many", false>;

/**
 * `owned` relationship — composition (Phase 2).
 *
 * An owned sub-shape is stored in a **dedicated child table**, prefixed by the
 * ownership path, with an FK to the immediate parent and `ON DELETE CASCADE`.
 * It can nest recursively (owned within owned). Cardinality:
 *
 *   - `owned({...})`          → 1:1, one child row.
 *   - `owned(array({...}))`   → 1:N, many child rows.
 *
 * Owned sub-entities get their own `id`/`createdAt`/`updatedAt`, like any table.
 */

type OwnedCardinality = "one" | "many";
/** A sub-shape: columns, further owned relationships, and/or references. */
type OwnedShape = Record<string, Column<unknown, boolean, boolean> | AnyOwned | AnyReference>;
/** Options for an owned relationship. */
interface OwnedOptions {
    /** Override the generated child-table name (escape valve for deep nesting). */
    table?: string;
}
/** An owned relationship node in a shape. */
declare class Owned<TShape extends OwnedShape, TCard extends OwnedCardinality> {
    readonly shape: TShape;
    readonly cardinality: TCard;
    readonly options: OwnedOptions;
    /** Stable field id (UUID) — survives rename. Normally emitted by `weave gen`. */
    readonly id?: string | undefined;
    /** Mirror target entity name — the base whose shape is copied in (snapshot). */
    readonly mirrorName?: string | undefined;
    readonly kind: "owned";
    constructor(shape: TShape, cardinality: TCard, options: OwnedOptions, 
    /** Stable field id (UUID) — survives rename. Normally emitted by `weave gen`. */
    id?: string | undefined, 
    /** Mirror target entity name — the base whose shape is copied in (snapshot). */
    mirrorName?: string | undefined);
    /** Pin a stable field id (survives rename). Normally emitted by `weave gen`. */
    $id(id: string): Owned<TShape, TCard>;
}
/** An owned relationship of any shape/cardinality. */
type AnyOwned = Owned<OwnedShape, OwnedCardinality>;
/** Marker produced by `array({...})` to signal a 1:N owned set. */
declare class OwnedArray<TShape extends OwnedShape> {
    readonly shape: TShape;
    /** Mirror target name when built from `array(mirror(...))`. */
    readonly mirrorName?: string | undefined;
    readonly kind: "owned_array";
    constructor(shape: TShape, 
    /** Mirror target name when built from `array(mirror(...))`. */
    mirrorName?: string | undefined);
}
/**
 * Snapshot of another entity's shape into an owned child — a **mirror**. The base's
 * fields are copied in (materialized server-side), plus any local extras. Takes the
 * ENTITY (like `reference`), not its name. `TShape` is the type-level merged shape
 * (base ⋂ extras); at runtime it carries only the extras + the base's name.
 */
declare class Mirror<TShape extends OwnedShape> {
    readonly mirrorName: string;
    /** Local extra fields (the base is resolved server-side). */
    readonly extra: OwnedShape;
    readonly kind: "mirror";
    constructor(mirrorName: string, 
    /** Local extra fields (the base is resolved server-side). */
    extra: OwnedShape);
}
/** Mirror an entity's shape into an owned child, optionally adding local fields. */
declare function mirror<TBase extends ShapeRecord, TExtra extends OwnedShape = {}>(entity: Entity<string, TBase>, extra?: TExtra): Mirror<TBase & TExtra>;
/** Declare an owned 1:1 relationship. */
declare function owned<TShape extends OwnedShape>(shape: TShape, options?: OwnedOptions): Owned<TShape, "one">;
/** Declare an owned 1:1 mirror (`owned(mirror(base, { extras }))`). */
declare function owned<TShape extends OwnedShape>(m: Mirror<TShape>, options?: OwnedOptions): Owned<TShape, "one">;
/** Declare an owned 1:N relationship (from `array({...})` or `array(mirror(...))`). */
declare function owned<TShape extends OwnedShape>(set: OwnedArray<TShape>, options?: OwnedOptions): Owned<TShape, "many">;

/** Função de transporte: recebe um `Request`, devolve um `Response` (WHATWG fetch).
 *  Aceita retorno síncrono ou Promise (o `app.hono.fetch` pode ser síncrono). */
type FetchLike = (request: Request) => Response | Promise<Response>;
interface ClientOptions<S> {
    /** Base URL do Weave (ex.: `https://weave.minha-loja.com`). */
    url: string;
    /** API key (`x-api-key`). */
    key: string;
    /** O entities-as-code: `{ nome: defineEntity(...) }`. */
    entities: S;
    /** Transporte. Default: `globalThis.fetch`. Nos testes: `app.hono.fetch`. */
    fetch?: FetchLike;
    /** @internal — scope ativo (`x-weave-scope`), definido via `weave.as(...)`. */
    scope?: string;
    /** @internal — params do scope (`x-weave-params`). */
    params?: Record<string, unknown>;
}
/**
 * Modificadores de leitura, **tipados pela entidade**: `orderBy` (`OrderByInput`),
 * `expand` (`ExpandInput`, dirige o tipo → `InferRead<E, X>`) e `select` (`SelectInput`,
 * whitelist de leitura ENXUTA — dirige o tipo → `InferSelect<E, S>`). O `where` NÃO vem
 * aqui — é o 1º argumento cru do método.
 */
interface ReadOpts<E extends Entity<string, ShapeRecord>, X, S> {
    orderBy?: OrderByInput<E>;
    expand?: X & ExpandInput<E>;
    /**
     * `select` — whitelist de leitura enxuta (subsume o `expand`): só hidrata o nomeado,
     * `id` sempre (timestamps se selecionados). Aninhado (espelha a árvore): `true` =
     * subárvore inteira, `{ … }` = parcial, omitido = pula. Pro caso de LISTA de entity
     * profunda (não puxa os owned que a tela não mostra). Ausente = leitura cheia de sempre
     * (owned + auto-expand). A forma é validada pela constraint `S extends SelectInput<E>`
     * nos métodos — `select?: S` puro aqui pra o `S` inferir EXATAMENTE o argumento (a
     * intersecção `S & SelectInput` vazava o SelectInput pro S e alargava o InferSelect).
     */
    select?: S;
    /**
     * Greatest-n-per-group: uma linha por combinação destes campos (`DISTINCT ON`).
     * O `orderBy` decide qual sobrevive (ex.: `{ ts: "desc" }` → a mais recente).
     * É o widget de métricas vivas ("o doc mais recente por worker/container").
     */
    latestPer?: (keyof E["columns"] & string)[];
    /**
     * Máximo de linhas do `findMany`. Default **10 000** ({@link DEFAULT_LIMIT}) — a rede de
     * segurança pra você não puxar uma tabela inteira sem querer. Suba pra ler mais de uma
     * vez, ou baixe pra um teto menor; pra UI paginada / listas realmente grandes, use
     * `paginate`. Se o filtro casar MAIS linhas que o limite, o `findMany` **avisa** (o corte
     * nunca é mudo). Passar `limit` explícito cala o aviso — aí o teto é escolha sua.
     * (Ignorado por `findOne`, que é sempre 1; no `paginate`, quem manda é o `perPage`.)
     */
    limit?: number;
}
interface PageOpts<E extends Entity<string, ShapeRecord>, X, S> extends ReadOpts<E, X, S> {
    page?: number;
    perPage?: number;
}
/** Tipo do doc lido: `InferSelect` quando há `select` (whitelist), senão `InferRead` (expand). */
type ReadResult<E, X, S> = [S] extends [never] ? InferRead<E, X> : InferSelect<E, S>;
interface PageResult<T> {
    docs: T[];
    docsQuantity: number;
    pageQuantity: number;
    currentPage: number;
}
/**
 * Client tipado de UMA entidade. Uma linha se mira por **`where` cru** (1º arg) —
 * `{ id: "123" }` é açúcar pra `{ id: { eq: "123" } }`. Verbos com `One` pegam o
 * **primeiro match** (`orderBy` desempata); com `Many` operam em massa e devolvem
 * `{ count }`. Os reads se **auto-tipam pelo `expand`** (`const X` → `InferRead`).
 */
interface EntityClient<E extends Entity<string, ShapeRecord>> {
    create(input: InferInsert<E>): Promise<InferEntity<E>>;
    /** Cria em lote (ingest — uma transação). Devolve as linhas na ordem de entrada. */
    createMany(inputs: InferInsert<E>[]): Promise<InferEntity<E>[]>;
    findOne<const X = {}, const S extends SelectInput<E> = never>(where?: WhereInput<E>, opts?: ReadOpts<E, X, S>): Promise<ReadResult<E, X, S> | null>;
    findMany<const X = {}, const S extends SelectInput<E> = never>(where?: WhereInput<E>, opts?: ReadOpts<E, X, S>): Promise<ReadResult<E, X, S>[]>;
    paginate<const X = {}, const S extends SelectInput<E> = never>(where?: WhereInput<E>, opts?: PageOpts<E, X, S>): Promise<PageResult<ReadResult<E, X, S>>>;
    updateOne(where: WhereInput<E>, patch: Partial<InferInsert<E>>, opts?: {
        orderBy?: OrderByInput<E>;
    }): Promise<InferEntity<E> | null>;
    updateMany(where: WhereInput<E>, patch: Partial<InferInsert<E>>): Promise<{
        count: number;
    }>;
    deleteOne(where: WhereInput<E>, opts?: {
        orderBy?: OrderByInput<E>;
    }): Promise<InferEntity<E> | null>;
    deleteMany(where: WhereInput<E>): Promise<{
        count: number;
    }>;
    /**
     * Agrega (groupBy + acumuladores + having + orderBy). Sem `facets` no input,
     * devolve `AggregateRow[]`; COM `facets`, devolve `{ rows, facets }` — o tipo de
     * retorno se auto-ajusta ao input (igual o `expand`).
     */
    aggregate<const I extends AggregateInput<E>>(input: I): Promise<AggregateOutput<I>>;
    /**
     * Acumula no tier histórico: um upsert mergeável na `key` (o unique declarado da
     * entidade), aplicando `ops` (`inc`/`max`/`min`/`setOnInsert`) atomicamente no
     * Postgres. Devolve a linha resultante (inc-and-return). A média se deriva na
     * LEITURA (`sum/count`) — nunca se guarda média pronta.
     */
    accumulate(key: Partial<InferInsert<E>>, ops: Record<string, AccumulateOp>): Promise<InferEntity<E>>;
}
/** O client completo: uma propriedade por entidade do entities + `as` (scope). */
type WeaveClient<S extends Record<string, Entity<string, ShapeRecord>>> = {
    [K in keyof S]: EntityClient<S[K]>;
} & {
    /**
     * Client escopado: toda requisição leva `x-weave-scope` + `x-weave-params`. Aceita o
     * OBJETO do scope (`defineScope(...)`) — recomendado — ou o nome (string). Quando o
     * scope infere params (`{ param: "x" }` no where), o objeto de params vira OBRIGATÓRIO
     * e tipado (`.as(admin, { companyId })`); sem params, é opcional.
     */
    as<P extends string = never>(scope: ScopeDef<P> | string, ...rest: [P] extends [never] ? [params?: Record<string, unknown>] : [params: {
        [K in P]: unknown;
    }]): WeaveClient<S>;
    /**
     * Factory reset — **dev/test only**. Zera o banco pra estado virgem (apaga dados,
     * tabelas de entity e o schema todo); um `push` em seguida reconstrói. Só funciona
     * se o servidor tiver `WEAVE_DEV_MODE` setada — senão responde 403 e não faz nada.
     */
    reset(): Promise<void>;
};
/**
 * Cria o client tipado a partir do entities-as-code. Casca fina sobre a API HTTP do
 * Weave: monta o request, manda o `x-api-key`, revive `obj↔json` (datas) pela forma
 * da entidade, e serializa o `expand` no param. O `fetch` é injetável — em teste,
 * `app.hono.fetch`.
 */
declare function createClient<S extends Record<string, Entity<string, ShapeRecord>>>(options: ClientOptions<S>): WeaveClient<S>;

type Verb = "read" | "create" | "update" | "delete";
/** Config de uma regra (sem a entity — ela vem por referência no `scopeRule`), TIPADA
 *  contra a entity `E`: `where` é um `WhereInput<E>` param-aware, `fields` são dot-paths
 *  de `E`. Typo/rename num campo/path viram erro de compilação, nunca falha silenciosa. */
interface ScopeRuleConfig<E extends Entity<string, ShapeRecord> = Entity<string, ShapeRecord>> {
    verbs: readonly Verb[];
    /** Filtro de linhas: `WhereInput<E>` onde qualquer folha aceita `{ param: "x" }`. */
    where?: ScopeWhereInput<E>;
    /** Projeção: dot-paths de `E` (`"whatsapp"`, `"summaryForTheManager.expectedRoi"`). */
    fields?: {
        include?: FieldPath<E>[];
        exclude?: FieldPath<E>[];
    };
}
/** Uma regra já resolvida (type-erased): o nome LÓGICO da entity (`entity.name`) + a
 *  config frouxa. `Params` é um phantom com os nomes de param inferidos do `where`. */
interface ScopeRule<Params extends string = string> {
    entity: string;
    verbs: Verb[];
    where?: Record<string, unknown>;
    fields?: {
        include?: string[];
        exclude?: string[];
    };
    /** @internal phantom — nomes de param (`{ param: "x" }`) inferidos do `where`. */
    readonly __params?: Params;
}
/** Nomes de param no `where` de uma config (vazio quando não há `where`). */
type WhereParams<C> = C extends {
    where: infer W;
} ? ExtractParams<W> : never;
interface ScopeEntityRule {
    verbs: Verb[];
    where?: Record<string, unknown>;
    fields?: {
        include?: string[];
        exclude?: string[];
    };
}
/** `Params` = union dos nomes de param inferidos das regras — o `weave.as` tipa contra isso. */
interface ScopeDef<Params extends string = never> {
    name: string;
    entities: Record<string, ScopeEntityRule>;
    /** @internal phantom — carrega os nomes de param pro `weave.as`. */
    readonly __params?: Params;
}
/**
 * Amarra uma regra a uma ENTITY por referência. O binding sai de `entity.name` (o nome
 * LÓGICO canônico — camelCase como você escreveu no `defineEntity`), não de uma string —
 * então typo/casing/snake_case não existem aqui. Espelha o `reference(entity)`. O `const`
 * na config preserva os literais dos `{ param: "x" }` pra inferência (Pedido 2d).
 */
declare function scopeRule<E extends Entity<string, ShapeRecord>, const C>(entity: E, config: C & ScopeRuleConfig<E>): ScopeRule<WhereParams<C>>;
/** Union dos params de todas as regras de um scope. */
type RulesParams<R extends readonly ScopeRule[]> = NonNullable<R[number]["__params"]>;
/**
 * Helper pro scope-as-code (igual `defineEntity`): nome + regras amarradas por `scopeRule`.
 * Devolve `ScopeDef<Params>` com os nomes de param INFERIDOS das regras — o `weave.as`
 * usa isso pra tipar (e exigir) o objeto de params na chamada, sem você declarar nada.
 */
declare function defineScope<const R extends readonly ScopeRule[]>(name: string, rules: R): ScopeDef<RulesParams<R>>;
interface PushScopesOptions {
    url: string;
    key: string;
    fetch?: FetchLike;
}
/**
 * Empurra scopes-as-code: converte cada regra (where + fields por NOME) pro formato
 * por-id e grava via `PUT /admin/scopes/:name`. Busca os IRs das entidades pra
 * resolver os ids (rename-proof no storage).
 */
declare function pushScopes(scopes: Record<string, ScopeDef<string>>, options: PushScopesOptions): Promise<{
    pushed: string[];
}>;

export { percentile as $, type AccumulateInput as A, count as B, Column as C, createClient as D, type Entity as E, type FetchLike as F, type GroupExpr as G, defineEntity as H, type InferEntity as I, defineScope as J, distinct as K, div as L, Mirror as M, first as N, type OwnedShape as O, type PageOpts as P, histogram as Q, ReferenceArray as R, type ShapeRecord as S, inc as T, max as U, type Verb as V, type WeaveClient as W, min as X, mirror as Y, mul as Z, owned as _, type ScopeDef as a, pushScopes as a0, reference as a1, scopeRule as a2, self as a3, setOnInsert as a4, sub as a5, sum as a6, timeBucket as a7, SelfMarker as b, OwnedArray as c, type ClientOptions as d, type OrderByInput as e, type InferInsert as f, type WhereInput as g, type AccumulateOp as h, type Accumulator as i, type AggOpts as j, type AggregateInput as k, type AggregateOutput as l, type AggregateRow as m, type EntityClient as n, type Expr as o, type ExprOperand as p, type FacetInput as q, type InferRead as r, type PageResult as s, type PushScopesOptions as t, type ReadOpts as u, type ScopeEntityRule as v, type ScopeRule as w, type ScopeRuleConfig as x, add as y, avg as z };