@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/db/dist/index.d.ts

@@ -1,1111 +0,0 @@
-import { AuraResponse, AuraClientLike, CountMode, BaseService, SchemaTable, SchemaFunction, SchemaEnum } from '@aurabase/core';
-
-type GenericRelationship = {
-    foreignKeyName: string;
-    columns: string[];
-    isOneToOne?: boolean;
-    referencedRelation: string;
-    referencedColumns: string[];
-};
-type GenericTable = {
-    Row: Record<string, unknown>;
-    Insert: Record<string, unknown>;
-    Update: Record<string, unknown>;
-    Relationships: GenericRelationship[];
-};
-type GenericUpdatableView = {
-    Row: Record<string, unknown>;
-    Insert: Record<string, unknown>;
-    Update: Record<string, unknown>;
-    Relationships: GenericRelationship[];
-};
-type GenericNonUpdatableView = {
-    Row: Record<string, unknown>;
-    Relationships: GenericRelationship[];
-};
-type GenericView = GenericUpdatableView | GenericNonUpdatableView;
-type GenericSetofOption = {
-    isSetofReturn?: boolean | undefined;
-    isOneToOne?: boolean | undefined;
-    isNotNullable?: boolean | undefined;
-    to: string;
-    from: string;
-};
-type GenericFunction = {
-    Args: Record<string, unknown> | never;
-    Returns: unknown;
-    SetofOptions?: GenericSetofOption;
-};
-type GenericSchema = {
-    Tables: Record<string, GenericTable>;
-    Views: Record<string, GenericView>;
-    Functions: Record<string, GenericFunction>;
-};
-type ClientServerOptions = {
-    PostgrestVersion?: string;
-};
-
-type AggregateWithoutColumnFunctions = 'count';
-type AggregateWithColumnFunctions = 'sum' | 'avg' | 'min' | 'max' | AggregateWithoutColumnFunctions;
-type AggregateFunctions = AggregateWithColumnFunctions;
-type Json = string | number | boolean | null | {
-    [key: string]: Json | undefined;
-} | Json[];
-type PostgresSQLNumberTypes = 'int2' | 'int4' | 'int8' | 'float4' | 'float8' | 'numeric';
-type PostgresSQLStringTypes = 'bytea' | 'bpchar' | 'varchar' | 'date' | 'text' | 'citext' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'uuid' | 'vector';
-type SingleValuePostgreSQLTypes = PostgresSQLNumberTypes | PostgresSQLStringTypes | 'bool' | 'json' | 'jsonb' | 'void' | 'record' | string;
-type ArrayPostgreSQLTypes = `_${SingleValuePostgreSQLTypes}`;
-type TypeScriptSingleValueTypes<T extends SingleValuePostgreSQLTypes> = T extends 'bool' ? boolean : T extends PostgresSQLNumberTypes ? number : T extends PostgresSQLStringTypes ? string : T extends 'json' | 'jsonb' ? Json : T extends 'void' ? undefined : T extends 'record' ? Record<string, unknown> : unknown;
-type StripUnderscore<T extends string> = T extends `_${infer U}` ? U : T;
-type PostgreSQLTypes = SingleValuePostgreSQLTypes | ArrayPostgreSQLTypes;
-type TypeScriptTypes<T extends PostgreSQLTypes> = T extends ArrayPostgreSQLTypes ? TypeScriptSingleValueTypes<StripUnderscore<Extract<T, SingleValuePostgreSQLTypes>>>[] : TypeScriptSingleValueTypes<T>;
-type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LastOf$1<T> = UnionToIntersection$1<T extends any ? () => T : never> extends () => infer R ? R : never;
-type Push<T extends any[], V> = [...T, V];
-type UnionToTuple<T, L = LastOf$1<T>, N = [T] extends [never] ? true : false> = N extends true ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
-type UnionToArray<T> = UnionToTuple<T>;
-type ExtractFirstProperty<T> = T extends {
-    [K in keyof T]: infer U;
-} ? U : never;
-type ContainsNull<T> = null extends T ? true : false;
-type IsNonEmptyArray<T> = Exclude<T, undefined> extends readonly [unknown, ...unknown[]] ? true : false;
-type TablesAndViews$1<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>;
-
-type IsAny$1<T> = 0 extends 1 & T ? true : false;
-type SelectQueryError<Message extends string> = {
-    error: true;
-} & Message;
-type DeduplicateRelationships<T extends readonly unknown[]> = T extends readonly [
-    infer First,
-    ...infer Rest
-] ? First extends Rest[number] ? DeduplicateRelationships<Rest extends readonly unknown[] ? Rest : []> : [First, ...DeduplicateRelationships<Rest extends readonly unknown[] ? Rest : []>] : T;
-type GetFieldNodeResultName<Field extends Ast.FieldNode> = Field['alias'] extends string ? Field['alias'] : Field['aggregateFunction'] extends AggregateFunctions ? Field['aggregateFunction'] : Field['name'];
-type FilterRelationNodes<Nodes extends Ast.Node[]> = UnionToArray<{
-    [K in keyof Nodes]: Nodes[K] extends Ast.SpreadNode ? Nodes[K]['target'] : Nodes[K] extends Ast.FieldNode ? IsNonEmptyArray<Nodes[K]['children']> extends true ? Nodes[K] : never : never;
-}[number]>;
-type ResolveRelationships<Schema extends GenericSchema, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.FieldNode[]> = UnionToArray<{
-    [K in keyof Nodes]: Nodes[K] extends Ast.FieldNode ? ResolveRelationship<Schema, Relationships, Nodes[K], RelationName> extends infer Relation ? Relation extends {
-        relation: {
-            referencedRelation: string;
-            foreignKeyName: string;
-            match: string;
-        };
-        from: string;
-    } ? {
-        referencedTable: Relation['relation']['referencedRelation'];
-        fkName: Relation['relation']['foreignKeyName'];
-        from: Relation['from'];
-        match: Relation['relation']['match'];
-        fieldName: GetFieldNodeResultName<Nodes[K]>;
-    } : Relation : never : never;
-}>[0];
-/**
- * Checks if a relation is implicitly referenced twice, requiring disambiguation
- */
-type IsDoubleReference<T, U> = T extends {
-    referencedTable: infer RT;
-    fieldName: infer FN;
-    match: infer M;
-} ? M extends 'col' | 'refrel' ? U extends {
-    referencedTable: RT;
-    fieldName: FN;
-    match: M;
-} ? true : false : false : false;
-/**
- * Compares one element with all other elements in the array to find duplicates
- */
-type CheckDuplicates<Arr extends any[], Current> = Arr extends [infer Head, ...infer Tail] ? IsDoubleReference<Current, Head> extends true ? Head | CheckDuplicates<Tail, Current> : CheckDuplicates<Tail, Current> : never;
-/**
- * Iterates over the elements of the array to find duplicates
- */
-type FindDuplicatesWithinDeduplicated<Arr extends any[]> = Arr extends [infer Head, ...infer Tail] ? CheckDuplicates<Tail, Head> | FindDuplicatesWithinDeduplicated<Tail> : never;
-type FindDuplicates<Arr extends any[]> = FindDuplicatesWithinDeduplicated<DeduplicateRelationships<Arr>>;
-type CheckDuplicateEmbededReference<Schema extends GenericSchema, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.Node[]> = FilterRelationNodes<Nodes> extends infer RelationsNodes ? RelationsNodes extends Ast.FieldNode[] ? ResolveRelationships<Schema, RelationName, Relationships, RelationsNodes> extends infer ResolvedRels ? ResolvedRels extends unknown[] ? FindDuplicates<ResolvedRels> extends infer Duplicates ? Duplicates extends never ? false : Duplicates extends {
-    fieldName: infer FieldName;
-} ? FieldName extends string ? {
-    [K in FieldName]: SelectQueryError<`table "${RelationName}" specified more than once use hinting for desambiguation`>;
-} : false : false : false : false : false : false : false;
-/**
- * Returns a boolean representing whether there is a foreign key referencing
- * a given relation.
- */
-type HasFKeyToFRel<FRelName, Relationships> = Relationships extends [infer R] ? R extends {
-    referencedRelation: FRelName;
-} ? true : false : Relationships extends [infer R, ...infer Rest] ? HasFKeyToFRel<FRelName, [R]> extends true ? true : HasFKeyToFRel<FRelName, Rest> : false;
-/**
- * Checks if there is more than one relation to a given foreign relation name in the Relationships.
- */
-type HasMultipleFKeysToFRelDeduplicated<FRelName, Relationships> = Relationships extends [
-    infer R,
-    ...infer Rest
-] ? R extends {
-    referencedRelation: FRelName;
-} ? HasFKeyToFRel<FRelName, Rest> extends true ? true : HasMultipleFKeysToFRelDeduplicated<FRelName, Rest> : HasMultipleFKeysToFRelDeduplicated<FRelName, Rest> : false;
-type HasMultipleFKeysToFRel<FRelName, Relationships extends unknown[]> = HasMultipleFKeysToFRelDeduplicated<FRelName, DeduplicateRelationships<Relationships>>;
-type CheckRelationshipError<Schema extends GenericSchema, Relationships extends GenericRelationship[], CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string, FoundRelation> = FoundRelation extends SelectQueryError<string> ? FoundRelation : FoundRelation extends {
-    relation: {
-        referencedRelation: infer RelatedRelationName;
-        name: string;
-    };
-    direction: 'reverse';
-} ? RelatedRelationName extends string ? HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true ? SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`> : FoundRelation : never : FoundRelation extends {
-    relation: {
-        referencedRelation: infer RelatedRelationName;
-        name: string;
-    };
-    direction: 'forward';
-    from: infer From;
-} ? RelatedRelationName extends string ? From extends keyof TablesAndViews$1<Schema> & string ? HasMultipleFKeysToFRel<RelatedRelationName, TablesAndViews$1<Schema>[From]['Relationships']> extends true ? SelectQueryError<`Could not embed because more than one relationship was found for '${From}' and '${RelatedRelationName}' you need to hint the column with ${From}!<columnName> ?`> : FoundRelation : never : never : FoundRelation;
-/**
- * Resolves relationships for embedded resources and retrieves the referenced Table
- */
-type ResolveRelationship<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string> = ResolveReverseRelationship<Schema, Relationships, Field, CurrentTableOrView> extends infer ReverseRelationship ? ReverseRelationship extends false ? CheckRelationshipError<Schema, Relationships, CurrentTableOrView, ResolveForwardRelationship<Schema, Field, CurrentTableOrView>> : CheckRelationshipError<Schema, Relationships, CurrentTableOrView, ReverseRelationship> : never;
-/**
- * Resolves reverse relationships (from children to parent)
- */
-type ResolveReverseRelationship<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string> = FindFieldMatchingRelationships<Schema, Relationships, Field> extends infer FoundRelation ? FoundRelation extends never ? false : FoundRelation extends {
-    referencedRelation: infer RelatedRelationName;
-} ? RelatedRelationName extends string ? RelatedRelationName extends keyof TablesAndViews$1<Schema> ? FoundRelation extends {
-    hint: string;
-} ? {
-    referencedTable: TablesAndViews$1<Schema>[RelatedRelationName];
-    relation: FoundRelation;
-    direction: 'reverse';
-    from: CurrentTableOrView;
-} : HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true ? SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`> : {
-    referencedTable: TablesAndViews$1<Schema>[RelatedRelationName];
-    relation: FoundRelation;
-    direction: 'reverse';
-    from: CurrentTableOrView;
-} : SelectQueryError<`Relation '${RelatedRelationName}' not found in schema.`> : false : false : false;
-type FindMatchingTableRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], value extends string> = Relationships extends [infer R, ...infer Rest] ? Rest extends GenericRelationship[] ? R extends {
-    referencedRelation: infer ReferencedRelation;
-} ? ReferencedRelation extends keyof Schema['Tables'] ? R extends {
-    foreignKeyName: value;
-} ? R & {
-    match: 'fkname';
-} : R extends {
-    referencedRelation: value;
-} ? R & {
-    match: 'refrel';
-} : R extends {
-    columns: [value];
-} ? R & {
-    match: 'col';
-} : FindMatchingTableRelationships<Schema, Rest, value> : FindMatchingTableRelationships<Schema, Rest, value> : false : false : false;
-type FindMatchingViewRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], value extends string> = Relationships extends [infer R, ...infer Rest] ? Rest extends GenericRelationship[] ? R extends {
-    referencedRelation: infer ReferencedRelation;
-} ? ReferencedRelation extends keyof Schema['Views'] ? R extends {
-    foreignKeyName: value;
-} ? R & {
-    match: 'fkname';
-} : R extends {
-    referencedRelation: value;
-} ? R & {
-    match: 'refrel';
-} : R extends {
-    columns: [value];
-} ? R & {
-    match: 'col';
-} : FindMatchingViewRelationships<Schema, Rest, value> : FindMatchingViewRelationships<Schema, Rest, value> : false : false : false;
-type FindMatchingHintTableRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], hint extends string, name extends string> = Relationships extends [infer R, ...infer Rest] ? Rest extends GenericRelationship[] ? R extends {
-    referencedRelation: infer ReferencedRelation;
-} ? ReferencedRelation extends name ? R extends {
-    foreignKeyName: hint;
-} ? R & {
-    match: 'fkname';
-} : R extends {
-    referencedRelation: hint;
-} ? R & {
-    match: 'refrel';
-} : R extends {
-    columns: [hint];
-} ? R & {
-    match: 'col';
-} : FindMatchingHintTableRelationships<Schema, Rest, hint, name> : FindMatchingHintTableRelationships<Schema, Rest, hint, name> : false : false : false;
-type FindMatchingHintViewRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], hint extends string, name extends string> = Relationships extends [infer R, ...infer Rest] ? Rest extends GenericRelationship[] ? R extends {
-    referencedRelation: infer ReferencedRelation;
-} ? ReferencedRelation extends name ? R extends {
-    foreignKeyName: hint;
-} ? R & {
-    match: 'fkname';
-} : R extends {
-    referencedRelation: hint;
-} ? R & {
-    match: 'refrel';
-} : R extends {
-    columns: [hint];
-} ? R & {
-    match: 'col';
-} : FindMatchingHintViewRelationships<Schema, Rest, hint, name> : FindMatchingHintViewRelationships<Schema, Rest, hint, name> : false : false : false;
-type IsColumnsNullable<Table extends Pick<GenericTable, 'Row'>, Columns extends (keyof Table['Row'])[]> = Columns extends [infer Column, ...infer Rest] ? Column extends keyof Table['Row'] ? ContainsNull<Table['Row'][Column]> extends true ? true : IsColumnsNullable<Table, Rest extends (keyof Table['Row'])[] ? Rest : []> : false : false;
-type IsRelationNullable<Table extends GenericTable, Relation extends GenericRelationship> = IsColumnsNullable<Table, Relation['columns']>;
-type TableForwardRelationships<Schema extends GenericSchema, TName> = TName extends keyof TablesAndViews$1<Schema> ? UnionToArray<RecursivelyFindRelationships<Schema, TName, keyof TablesAndViews$1<Schema>>> extends infer R ? R extends (GenericRelationship & {
-    from: keyof TablesAndViews$1<Schema>;
-})[] ? R : [] : [] : [];
-type RecursivelyFindRelationships<Schema extends GenericSchema, TName, Keys extends keyof TablesAndViews$1<Schema>> = Keys extends infer K ? K extends keyof TablesAndViews$1<Schema> ? FilterRelationships<TablesAndViews$1<Schema>[K]['Relationships'], TName, K> extends never ? RecursivelyFindRelationships<Schema, TName, Exclude<Keys, K>> : FilterRelationships<TablesAndViews$1<Schema>[K]['Relationships'], TName, K> | RecursivelyFindRelationships<Schema, TName, Exclude<Keys, K>> : false : false;
-type FilterRelationships<R, TName, From> = R extends readonly (infer Rel)[] ? Rel extends {
-    referencedRelation: TName;
-} ? Rel & {
-    from: From;
-} : never : never;
-type ResolveForwardRelationship<Schema extends GenericSchema, Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string> = FindFieldMatchingRelationships<Schema, TablesAndViews$1<Schema>[Field['name']]['Relationships'], Ast.FieldNode & {
-    name: CurrentTableOrView;
-    hint: Field['hint'];
-}> extends infer FoundByName ? FoundByName extends GenericRelationship ? {
-    referencedTable: TablesAndViews$1<Schema>[Field['name']];
-    relation: FoundByName;
-    direction: 'forward';
-    from: Field['name'];
-    type: 'found-by-name';
-} : FindFieldMatchingRelationships<Schema, TableForwardRelationships<Schema, CurrentTableOrView>, Field> extends infer FoundByMatch ? FoundByMatch extends GenericRelationship & {
-    from: keyof TablesAndViews$1<Schema>;
-} ? {
-    referencedTable: TablesAndViews$1<Schema>[FoundByMatch['from']];
-    relation: FoundByMatch;
-    direction: 'forward';
-    from: CurrentTableOrView;
-    type: 'found-by-match';
-} : FindJoinTableRelationship<Schema, CurrentTableOrView, Field['name']> extends infer FoundByJoinTable ? FoundByJoinTable extends GenericRelationship ? {
-    referencedTable: TablesAndViews$1<Schema>[FoundByJoinTable['referencedRelation']];
-    relation: FoundByJoinTable & {
-        match: 'refrel';
-    };
-    direction: 'forward';
-    from: CurrentTableOrView;
-    type: 'found-by-join-table';
-} : ResolveEmbededFunctionJoinTableRelationship<Schema, CurrentTableOrView, Field['name']> extends infer FoundEmbededFunctionJoinTableRelation ? FoundEmbededFunctionJoinTableRelation extends GenericFunction ? FoundEmbededFunctionJoinTableRelation['SetofOptions'] extends GenericSetofOption ? FoundEmbededFunctionJoinTableRelation['SetofOptions']['to'] extends '' ? {
-    referencedTable: {
-        Row: Record<string, never>;
-        Relationships: [];
-    };
-    relation: {
-        foreignKeyName: `${Field['name']}_${CurrentTableOrView}_scalar_forward`;
-        columns: [];
-        isOneToOne: false;
-        referencedColumns: [];
-        referencedRelation: '';
-    } & {
-        match: 'func';
-        isNotNullable: FoundEmbededFunctionJoinTableRelation['SetofOptions']['isNotNullable'] extends true ? true : FoundEmbededFunctionJoinTableRelation['SetofOptions']['isSetofReturn'] extends true ? false : true;
-        isSetofReturn: FoundEmbededFunctionJoinTableRelation['SetofOptions']['isSetofReturn'];
-    };
-    scalarType: FoundEmbededFunctionJoinTableRelation['Returns'];
-    direction: 'forward';
-    from: CurrentTableOrView;
-    type: 'found-by-embeded-scalar-function';
-} : {
-    referencedTable: TablesAndViews$1<Schema>[FoundEmbededFunctionJoinTableRelation['SetofOptions']['to']];
-    relation: {
-        foreignKeyName: `${Field['name']}_${CurrentTableOrView}_${FoundEmbededFunctionJoinTableRelation['SetofOptions']['to']}_forward`;
-        columns: [];
-        isOneToOne: FoundEmbededFunctionJoinTableRelation['SetofOptions']['isOneToOne'] extends true ? true : false;
-        referencedColumns: [];
-        referencedRelation: FoundEmbededFunctionJoinTableRelation['SetofOptions']['to'];
-    } & {
-        match: 'func';
-        isNotNullable: FoundEmbededFunctionJoinTableRelation['SetofOptions']['isNotNullable'] extends true ? true : FoundEmbededFunctionJoinTableRelation['SetofOptions']['isSetofReturn'] extends true ? false : true;
-        isSetofReturn: FoundEmbededFunctionJoinTableRelation['SetofOptions']['isSetofReturn'];
-    };
-    direction: 'forward';
-    from: CurrentTableOrView;
-    type: 'found-by-embeded-function';
-} : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`> : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`> : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`> : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`> : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`> : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>;
-/**
- * Given a CurrentTableOrView, finds all join tables to this relation.
- * For example, if products and categories are linked via product_categories table:
- *
- * @example Find join table relationship
- * Given:
- * - CurrentTableView = 'products'
- * - FieldName = "categories"
- *
- * It should return this relationship from product_categories:
- * {
- *   foreignKeyName: "product_categories_category_id_fkey",
- *   columns: ["category_id"],
- *   isOneToOne: false,
- *   referencedRelation: "categories",
- *   referencedColumns: ["id"]
- * }
- */
-type ResolveJoinTableRelationship<Schema extends GenericSchema, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string, FieldName extends string> = {
-    [TableName in keyof TablesAndViews$1<Schema>]: DeduplicateRelationships<TablesAndViews$1<Schema>[TableName]['Relationships']> extends readonly (infer Rel)[] ? Rel extends {
-        referencedRelation: CurrentTableOrView;
-    } ? DeduplicateRelationships<TablesAndViews$1<Schema>[TableName]['Relationships']> extends readonly (infer OtherRel)[] ? OtherRel extends {
-        referencedRelation: FieldName;
-    } ? OtherRel : never : never : never : never;
-}[keyof TablesAndViews$1<Schema>];
-type ResolveEmbededFunctionJoinTableRelationship<Schema extends GenericSchema, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string, FieldName extends string> = FindMatchingFunctionBySetofFrom<Schema['Functions'][FieldName], CurrentTableOrView> extends infer Fn ? Fn extends GenericFunction ? Fn : false : false;
-type FindJoinTableRelationship<Schema extends GenericSchema, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string, FieldName extends string> = ResolveJoinTableRelationship<Schema, CurrentTableOrView, FieldName> extends infer Result ? [Result] extends [never] ? false : Result : never;
-/**
- * Finds a matching relationship based on the FieldNode's name and optional hint.
- */
-type FindFieldMatchingRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode> = Field extends {
-    hint: string;
-} ? FindMatchingHintTableRelationships<Schema, Relationships, Field['hint'], Field['name']> extends GenericRelationship ? FindMatchingHintTableRelationships<Schema, Relationships, Field['hint'], Field['name']> & {
-    branch: 'found-in-table-via-hint';
-    hint: Field['hint'];
-} : FindMatchingHintViewRelationships<Schema, Relationships, Field['hint'], Field['name']> extends GenericRelationship ? FindMatchingHintViewRelationships<Schema, Relationships, Field['hint'], Field['name']> & {
-    branch: 'found-in-view-via-hint';
-    hint: Field['hint'];
-} : SelectQueryError<'Failed to find matching relation via hint'> : FindMatchingTableRelationships<Schema, Relationships, Field['name']> extends GenericRelationship ? FindMatchingTableRelationships<Schema, Relationships, Field['name']> & {
-    branch: 'found-in-table-via-name';
-    name: Field['name'];
-} : FindMatchingViewRelationships<Schema, Relationships, Field['name']> extends GenericRelationship ? FindMatchingViewRelationships<Schema, Relationships, Field['name']> & {
-    branch: 'found-in-view-via-name';
-    name: Field['name'];
-} : SelectQueryError<'Failed to find matching relation via name'>;
-type JsonPathToAccessor<Path extends string> = Path extends `${infer P1}->${infer P2}` ? P2 extends `>${infer Rest}` ? JsonPathToAccessor<`${P1}.${Rest}`> : P2 extends string ? JsonPathToAccessor<`${P1}.${P2}`> : Path : Path extends `>${infer Rest}` ? JsonPathToAccessor<Rest> : Path extends `${infer P1}::${infer _}` ? JsonPathToAccessor<P1> : Path extends `${infer P1}${')' | ','}${infer _}` ? P1 : Path;
-type JsonPathToType<T, Path extends string> = Path extends '' ? T : ContainsNull<T> extends true ? JsonPathToType<Exclude<T, null>, Path> : Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? JsonPathToType<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
-type IsStringUnion<T> = string extends T ? false : T extends string ? [T] extends [never] ? false : true : false;
-type MatchingFunctionBySetofFrom<Fn extends GenericFunction, TableName extends string> = Fn['SetofOptions'] extends GenericSetofOption ? TableName extends Fn['SetofOptions']['from'] ? Fn : never : false;
-type FindMatchingFunctionBySetofFrom<FnUnion, TableName extends string> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionBySetofFrom<Fn, TableName> : false;
-type ComputedField<Schema extends GenericSchema, RelationName extends keyof TablesAndViews$1<Schema>, FieldName extends keyof TablesAndViews$1<Schema>[RelationName]['Row']> = FieldName extends keyof Schema['Functions'] ? [Schema['Functions'][FieldName]['Args']] extends [never] ? never : Schema['Functions'][FieldName] extends {
-    Args: {
-        '': TablesAndViews$1<Schema>[RelationName]['Row'];
-    };
-    Returns: any;
-} ? FieldName : never : never;
-type GetComputedFields<Schema extends GenericSchema, RelationName extends keyof TablesAndViews$1<Schema>> = {
-    [K in keyof TablesAndViews$1<Schema>[RelationName]['Row']]: ComputedField<Schema, RelationName, K>;
-}[keyof TablesAndViews$1<Schema>[RelationName]['Row']];
-
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
-type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
-    [TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
-} : Type;
-type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-type BuiltIns = Primitive | void | Date | RegExp;
-type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-
-/**
- * Parses a query.
- * A query is a sequence of nodes, separated by `,`, ensuring that there is
- * no remaining input after all nodes have been parsed.
- *
- * Returns an array of parsed nodes, or an error.
- */
-type ParseQuery<Query extends string> = string extends Query ? GenericStringError : ParseNodes<EatWhitespace<Query>> extends [infer Nodes, `${infer Remainder}`] ? Nodes extends Ast.Node[] ? EatWhitespace<Remainder> extends '' ? SimplifyDeep<Nodes> : ParserError<`Unexpected input: ${Remainder}`> : ParserError<'Invalid nodes array structure'> : ParseNodes<EatWhitespace<Query>>;
-/**
- * Notes: all `Parse*` types assume that their input strings have their whitespace
- * removed. They return tuples of ["Return Value", "Remainder of text"] or
- * a `ParserError`.
- */
-/**
- * Parses a sequence of nodes, separated by `,`.
- *
- * Returns a tuple of ["Parsed fields", "Remainder of text"] or an error.
- */
-type ParseNodes<Input extends string> = string extends Input ? GenericStringError : ParseNodesHelper<Input, []>;
-type ParseNodesHelper<Input extends string, Nodes extends Ast.Node[]> = ParseNode<Input> extends [infer Node, `${infer Remainder}`] ? Node extends Ast.Node ? EatWhitespace<Remainder> extends `,${infer Remainder}` ? ParseNodesHelper<EatWhitespace<Remainder>, [...Nodes, Node]> : [[...Nodes, Node], EatWhitespace<Remainder>] : ParserError<'Invalid node type in nodes helper'> : ParseNode<Input>;
-/**
- * Parses a node.
- * A node is one of the following:
- * - `*`
- * - a field, as defined above
- * - a renamed field, `renamed_field:field`
- * - a spread field, `...field`
- */
-type ParseNode<Input extends string> = Input extends '' ? ParserError<'Empty string'> : Input extends `*${infer Remainder}` ? [Ast.StarNode, EatWhitespace<Remainder>] : Input extends `...${infer Remainder}` ? ParseField<EatWhitespace<Remainder>> extends [infer TargetField, `${infer Remainder}`] ? TargetField extends Ast.FieldNode ? [{
-    type: 'spread';
-    target: TargetField;
-}, EatWhitespace<Remainder>] : ParserError<'Invalid target field type in spread'> : ParserError<`Unable to parse spread resource at \`${Input}\``> : ParseIdentifier<Input> extends [infer NameOrAlias, `${infer Remainder}`] ? EatWhitespace<Remainder> extends `::${infer _}` ? ParseField<Input> : EatWhitespace<Remainder> extends `:${infer Remainder}` ? ParseField<EatWhitespace<Remainder>> extends [infer Field, `${infer Remainder}`] ? Field extends Ast.FieldNode ? [Omit<Field, 'alias'> & {
-    alias: NameOrAlias;
-}, EatWhitespace<Remainder>] : ParserError<'Invalid field type in alias parsing'> : ParserError<`Unable to parse renamed field at \`${Input}\``> : ParseField<Input> : ParserError<`Expected identifier at \`${Input}\``>;
-/**
- * Parses a field without preceding alias.
- * A field is one of the following:
- * - a top-level `count` field: https://docs.postgrest.org/en/v12/references/api/aggregate_functions.html#the-case-of-count
- * - a field with an embedded resource
- *   - `field(nodes)`
- *   - `field!hint(nodes)`
- *   - `field!inner(nodes)`
- *   - `field!left(nodes)`
- *   - `field!hint!inner(nodes)`
- *   - `field!hint!left(nodes)`
- * - a field without an embedded resource (see {@link ParseNonEmbeddedResourceField})
- */
-type ParseField<Input extends string> = Input extends '' ? ParserError<'Empty string'> : ParseIdentifier<Input> extends [infer Name, `${infer Remainder}`] ? Name extends 'count' ? ParseCountField<Input> : Remainder extends `!inner${infer Remainder}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-    infer Children,
-    `${infer Remainder}`
-] ? Children extends Ast.Node[] ? [
-    {
-        type: 'field';
-        name: Name;
-        innerJoin: true;
-        children: Children;
-    },
-    Remainder
-] : ParserError<'Invalid children array in inner join'> : CreateParserErrorIfRequired<ParseEmbeddedResource<EatWhitespace<Remainder>>, `Expected embedded resource after "!inner" at \`${Remainder}\``> : EatWhitespace<Remainder> extends `!left${infer Remainder}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-    infer Children,
-    `${infer Remainder}`
-] ? Children extends Ast.Node[] ? [
-    {
-        type: 'field';
-        name: Name;
-        children: Children;
-    },
-    EatWhitespace<Remainder>
-] : ParserError<'Invalid children array in left join'> : CreateParserErrorIfRequired<ParseEmbeddedResource<EatWhitespace<Remainder>>, `Expected embedded resource after "!left" at \`${EatWhitespace<Remainder>}\``> : EatWhitespace<Remainder> extends `!${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [infer Hint, `${infer Remainder}`] ? EatWhitespace<Remainder> extends `!inner${infer Remainder}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-    infer Children,
-    `${infer Remainder}`
-] ? Children extends Ast.Node[] ? [
-    {
-        type: 'field';
-        name: Name;
-        hint: Hint;
-        innerJoin: true;
-        children: Children;
-    },
-    EatWhitespace<Remainder>
-] : ParserError<'Invalid children array in hint inner join'> : ParseEmbeddedResource<EatWhitespace<Remainder>> : ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-    infer Children,
-    `${infer Remainder}`
-] ? Children extends Ast.Node[] ? [
-    {
-        type: 'field';
-        name: Name;
-        hint: Hint;
-        children: Children;
-    },
-    EatWhitespace<Remainder>
-] : ParserError<'Invalid children array in hint'> : ParseEmbeddedResource<EatWhitespace<Remainder>> : ParserError<`Expected identifier after "!" at \`${EatWhitespace<Remainder>}\``> : EatWhitespace<Remainder> extends `(${infer _}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-    infer Children,
-    `${infer Remainder}`
-] ? Children extends Ast.Node[] ? [
-    {
-        type: 'field';
-        name: Name;
-        children: Children;
-    },
-    EatWhitespace<Remainder>
-] : ParserError<'Invalid children array in field'> : ParseEmbeddedResource<EatWhitespace<Remainder>> : ParseNonEmbeddedResourceField<Input> : ParserError<`Expected identifier at \`${Input}\``>;
-type ParseCountField<Input extends string> = ParseIdentifier<Input> extends ['count', `${infer Remainder}`] ? (EatWhitespace<Remainder> extends `()${infer Remainder_}` ? EatWhitespace<Remainder_> : EatWhitespace<Remainder>) extends `${infer Remainder}` ? Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [infer CastType, `${infer Remainder}`] ? [
-    {
-        type: 'field';
-        name: 'count';
-        aggregateFunction: 'count';
-        castType: CastType;
-    },
-    Remainder
-] : ParseFieldTypeCast<Remainder> : [{
-    type: 'field';
-    name: 'count';
-    aggregateFunction: 'count';
-}, Remainder] : never : ParserError<`Expected "count" at \`${Input}\``>;
-/**
- * Parses an embedded resource, which is an opening `(`, followed by a sequence of
- * 0 or more nodes separated by `,`, then a closing `)`.
- *
- * Returns a tuple of ["Parsed fields", "Remainder of text"], an error,
- * or the original string input indicating that no opening `(` was found.
- */
-type ParseEmbeddedResource<Input extends string> = Input extends `(${infer Remainder}` ? EatWhitespace<Remainder> extends `)${infer Remainder}` ? [[], EatWhitespace<Remainder>] : ParseNodes<EatWhitespace<Remainder>> extends [infer Nodes, `${infer Remainder}`] ? Nodes extends Ast.Node[] ? EatWhitespace<Remainder> extends `)${infer Remainder}` ? [Nodes, EatWhitespace<Remainder>] : ParserError<`Expected ")" at \`${EatWhitespace<Remainder>}\``> : ParserError<'Invalid nodes array in embedded resource'> : ParseNodes<EatWhitespace<Remainder>> : ParserError<`Expected "(" at \`${Input}\``>;
-/**
- * Parses a field excluding embedded resources, without preceding field renaming.
- * This is one of the following:
- * - `field`
- * - `field.aggregate()`
- * - `field.aggregate()::type`
- * - `field::type`
- * - `field::type.aggregate()`
- * - `field::type.aggregate()::type`
- * - `field->json...`
- * - `field->json.aggregate()`
- * - `field->json.aggregate()::type`
- * - `field->json::type`
- * - `field->json::type.aggregate()`
- * - `field->json::type.aggregate()::type`
- */
-type ParseNonEmbeddedResourceField<Input extends string> = ParseIdentifier<Input> extends [infer Name, `${infer Remainder}`] ? (Remainder extends `->${infer PathAndRest}` ? ParseJsonAccessor<Remainder> extends [
-    infer PropertyName,
-    infer PropertyType,
-    `${infer Remainder}`
-] ? [
-    {
-        type: 'field';
-        name: Name;
-        alias: PropertyName;
-        castType: PropertyType;
-        jsonPath: JsonPathToAccessor<PathAndRest extends `${infer Path},${string}` ? Path : PathAndRest>;
-    },
-    Remainder
-] : ParseJsonAccessor<Remainder> : [{
-    type: 'field';
-    name: Name;
-}, Remainder]) extends infer Parsed ? Parsed extends [infer Field, `${infer Remainder}`] ? (Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [infer CastType, `${infer Remainder}`] ? [Omit<Field, 'castType'> & {
-    castType: CastType;
-}, Remainder] : ParseFieldTypeCast<Remainder> : [Field, Remainder]) extends infer Parsed ? Parsed extends [infer Field, `${infer Remainder}`] ? Remainder extends `.${infer _}` ? ParseFieldAggregation<Remainder> extends [
-    infer AggregateFunction,
-    `${infer Remainder}`
-] ? Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [infer CastType, `${infer Remainder}`] ? [
-    Omit<Field, 'castType'> & {
-        aggregateFunction: AggregateFunction;
-        castType: CastType;
-    },
-    Remainder
-] : ParseFieldTypeCast<Remainder> : [Field & {
-    aggregateFunction: AggregateFunction;
-}, Remainder] : ParseFieldAggregation<Remainder> : [Field, Remainder] : Parsed : never : Parsed : never : ParserError<`Expected identifier at \`${Input}\``>;
-/**
- * Parses a JSON property accessor of the shape `->a->b->c`. The last accessor in
- * the series may convert to text by using the ->> operator instead of ->.
- *
- * Returns a tuple of ["Last property name", "Last property type", "Remainder of text"]
- */
-type ParseJsonAccessor<Input extends string> = Input extends `->${infer Remainder}` ? Remainder extends `>${infer Remainder}` ? ParseIdentifier<Remainder> extends [infer Name, `${infer Remainder}`] ? [Name, 'text', EatWhitespace<Remainder>] : ParserError<'Expected property name after `->>`'> : ParseIdentifier<Remainder> extends [infer Name, `${infer Remainder}`] ? ParseJsonAccessor<Remainder> extends [
-    infer PropertyName,
-    infer PropertyType,
-    `${infer Remainder}`
-] ? [PropertyName, PropertyType, EatWhitespace<Remainder>] : [Name, 'json', EatWhitespace<Remainder>] : ParserError<'Expected property name after `->`'> : ParserError<'Expected ->'>;
-/**
- * Parses a field typecast (`::type`), returning a tuple of ["Type", "Remainder of text"].
- */
-type ParseFieldTypeCast<Input extends string> = EatWhitespace<Input> extends `::${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [`${infer CastType}`, `${infer Remainder}`] ? [CastType, EatWhitespace<Remainder>] : ParserError<`Invalid type for \`::\` operator at \`${Remainder}\``> : ParserError<'Expected ::'>;
-/**
- * Parses a field aggregation (`.max()`), returning a tuple of ["Aggregate function", "Remainder of text"]
- */
-type ParseFieldAggregation<Input extends string> = EatWhitespace<Input> extends `.${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [
-    `${infer FunctionName}`,
-    `${infer Remainder}`
-] ? FunctionName extends Token.AggregateFunction ? EatWhitespace<Remainder> extends `()${infer Remainder}` ? [FunctionName, EatWhitespace<Remainder>] : ParserError<`Expected \`()\` after \`.\` operator \`${FunctionName}\``> : ParserError<`Invalid type for \`.\` operator \`${FunctionName}\``> : ParserError<`Invalid type for \`.\` operator at \`${Remainder}\``> : ParserError<'Expected .'>;
-/**
- * Parses a (possibly double-quoted) identifier.
- * Identifiers are sequences of 1 or more letters.
- */
-type ParseIdentifier<Input extends string> = ParseLetters<Input> extends [infer Name, `${infer Remainder}`] ? [Name, EatWhitespace<Remainder>] : ParseQuotedLetters<Input> extends [infer Name, `${infer Remainder}`] ? [Name, EatWhitespace<Remainder>] : ParserError<`No (possibly double-quoted) identifier at \`${Input}\``>;
-/**
- * Parse a consecutive sequence of 1 or more letter, where letters are `[0-9a-zA-Z_]`.
- */
-type ParseLetters<Input extends string> = string extends Input ? GenericStringError : ParseLettersHelper<Input, ''> extends [`${infer Letters}`, `${infer Remainder}`] ? Letters extends '' ? ParserError<`Expected letter at \`${Input}\``> : [Letters, Remainder] : ParseLettersHelper<Input, ''>;
-type ParseLettersHelper<Input extends string, Acc extends string> = string extends Input ? GenericStringError : Input extends `${infer L}${infer Remainder}` ? L extends Token.Letter ? ParseLettersHelper<Remainder, `${Acc}${L}`> : [Acc, Input] : [Acc, ''];
-/**
- * Parse a consecutive sequence of 1 or more double-quoted letters,
- * where letters are `[^"]`.
- */
-type ParseQuotedLetters<Input extends string> = string extends Input ? GenericStringError : Input extends `"${infer Remainder}` ? ParseQuotedLettersHelper<Remainder, ''> extends [`${infer Letters}`, `${infer Remainder}`] ? Letters extends '' ? ParserError<`Expected string at \`${Remainder}\``> : [Letters, Remainder] : ParseQuotedLettersHelper<Remainder, ''> : ParserError<`Not a double-quoted string at \`${Input}\``>;
-type ParseQuotedLettersHelper<Input extends string, Acc extends string> = string extends Input ? GenericStringError : Input extends `${infer L}${infer Remainder}` ? L extends '"' ? [Acc, Remainder] : ParseQuotedLettersHelper<Remainder, `${Acc}${L}`> : ParserError<`Missing closing double-quote in \`"${Acc}${Input}\``>;
-/**
- * Trims whitespace from the left of the input.
- */
-type EatWhitespace<Input extends string> = string extends Input ? GenericStringError : Input extends `${Token.Whitespace}${infer Remainder}` ? EatWhitespace<Remainder> : Input;
-/**
- * Creates a new {@link ParserError} if the given input is not already a parser error.
- */
-type CreateParserErrorIfRequired<Input, Message extends string> = Input extends ParserError<string> ? Input : ParserError<Message>;
-/**
- * Parser errors.
- */
-type ParserError<Message extends string> = {
-    error: true;
-} & Message;
-type GenericStringError = ParserError<'Received a generic string'>;
-declare namespace Ast {
-    type Node = FieldNode | StarNode | SpreadNode;
-    type FieldNode = {
-        type: 'field';
-        name: string;
-        alias?: string;
-        hint?: string;
-        innerJoin?: true;
-        castType?: string;
-        jsonPath?: string;
-        aggregateFunction?: Token.AggregateFunction;
-        children?: Node[];
-    };
-    type StarNode = {
-        type: 'star';
-    };
-    type SpreadNode = {
-        type: 'spread';
-        target: FieldNode & {
-            children: Node[];
-        };
-    };
-}
-declare namespace Token {
-    export type Whitespace = ' ' | '\n' | '\t';
-    type LowerAlphabet = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
-    type Alphabet = LowerAlphabet | Uppercase<LowerAlphabet>;
-    type Digit = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '0';
-    export type Letter = Alphabet | Digit | '_';
-    export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
-    export {  };
-}
-
-type IsPostgrest13<PostgrestVersion extends string | undefined> = PostgrestVersion extends `13${string}` ? true : false;
-type IsPostgrest14<PostgrestVersion extends string | undefined> = PostgrestVersion extends `14${string}` ? true : false;
-type IsPostgrestVersionGreaterThan12<PostgrestVersion extends string | undefined> = IsPostgrest13<PostgrestVersion> extends true ? true : IsPostgrest14<PostgrestVersion> extends true ? true : false;
-type SpreadOnManyEnabled<PostgrestVersion extends string | undefined> = IsPostgrestVersionGreaterThan12<PostgrestVersion> extends true ? true : false;
-
-/**
- * Main entry point for constructing the result type of a PostgREST query.
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param Query - The select query string literal to parse.
- */
-type GetResult<Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName, Relationships, Query extends string, ClientOptions extends ClientServerOptions> = IsAny$1<Schema> extends true ? ParseQuery<Query> extends infer ParsedQuery ? ParsedQuery extends Ast.Node[] ? RelationName extends string ? ProcessNodesWithoutSchema<ParsedQuery> : any : ParsedQuery : any : Relationships extends null ? ParseQuery<Query> extends infer ParsedQuery ? ParsedQuery extends Ast.Node[] ? RPCCallNodes<ParsedQuery, RelationName extends string ? RelationName : 'rpc_call', Row> : ParsedQuery : Row : ParseQuery<Query> extends infer ParsedQuery ? ParsedQuery extends Ast.Node[] ? RelationName extends string ? Relationships extends GenericRelationship[] ? ProcessNodes<ClientOptions, Schema, Row, RelationName, Relationships, ParsedQuery> : SelectQueryError<'Invalid Relationships cannot infer result type'> : SelectQueryError<'Invalid RelationName cannot infer result type'> : ParsedQuery : never;
-type ProcessSimpleFieldWithoutSchema<Field extends Ast.FieldNode> = Field['aggregateFunction'] extends AggregateFunctions ? {
-    [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes ? TypeScriptTypes<Field['castType']> : number;
-} : {
-    [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes ? TypeScriptTypes<Field['castType']> : any;
-};
-type ProcessFieldNodeWithoutSchema<Node extends Ast.FieldNode> = IsNonEmptyArray<Node['children']> extends true ? {
-    [K in GetFieldNodeResultName<Node>]: Node['children'] extends Ast.Node[] ? ProcessNodesWithoutSchema<Node['children']>[] : ProcessSimpleFieldWithoutSchema<Node>;
-} : ProcessSimpleFieldWithoutSchema<Node>;
-/**
- * Processes a single Node without schema and returns the resulting TypeScript type.
- */
-type ProcessNodeWithoutSchema<Node extends Ast.Node> = Node extends Ast.StarNode ? any : Node extends Ast.SpreadNode ? Node['target']['children'] extends Ast.StarNode[] ? any : Node['target']['children'] extends Ast.FieldNode[] ? {
-    [P in Node['target']['children'][number] as GetFieldNodeResultName<P>]: P['castType'] extends PostgreSQLTypes ? TypeScriptTypes<P['castType']> : any;
-} : any : Node extends Ast.FieldNode ? ProcessFieldNodeWithoutSchema<Node> : any;
-/**
- * Processes nodes when Schema is any, providing basic type inference
- */
-type ProcessNodesWithoutSchema<Nodes extends Ast.Node[], Acc extends Record<string, unknown> = {}> = Nodes extends [infer FirstNode, ...infer RestNodes] ? FirstNode extends Ast.Node ? RestNodes extends Ast.Node[] ? ProcessNodeWithoutSchema<FirstNode> extends infer FieldResult ? FieldResult extends Record<string, unknown> ? ProcessNodesWithoutSchema<RestNodes, Acc & FieldResult> : FieldResult : any : any : any : Prettify<Acc>;
-/**
- * Processes a single Node from a select chained after a rpc call
- *
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current rpc function
- * @param NodeType - The Node to process.
- */
-type ProcessRPCNode<Row extends Record<string, unknown>, RelationName extends string, NodeType extends Ast.Node> = NodeType['type'] extends Ast.StarNode['type'] ? Row : NodeType['type'] extends Ast.FieldNode['type'] ? ProcessSimpleField<Row, RelationName, Extract<NodeType, Ast.FieldNode>> : SelectQueryError<'RPC Unsupported node type.'>;
-/**
- * Process select call that can be chained after an rpc call
- */
-type RPCCallNodes<Nodes extends Ast.Node[], RelationName extends string, Row extends Record<string, unknown>, Acc extends Record<string, unknown> = {}> = Nodes extends [infer FirstNode, ...infer RestNodes] ? FirstNode extends Ast.Node ? RestNodes extends Ast.Node[] ? ProcessRPCNode<Row, RelationName, FirstNode> extends infer FieldResult ? FieldResult extends Record<string, unknown> ? RPCCallNodes<RestNodes, RelationName, Row, Acc & FieldResult> : FieldResult extends SelectQueryError<infer E> ? SelectQueryError<E> : SelectQueryError<'Could not retrieve a valid record or error value'> : SelectQueryError<'Processing node failed.'> : SelectQueryError<'Invalid rest nodes array in RPC call'> : SelectQueryError<'Invalid first node in RPC call'> : Prettify<Acc>;
-/**
- * Recursively processes an array of Nodes and accumulates the resulting TypeScript type.
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param Nodes - An array of AST nodes to process.
- * @param Acc - Accumulator for the constructed type.
- */
-type ProcessNodes<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.Node[], Acc extends Record<string, unknown> = {}> = CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes> extends false ? Nodes extends [infer FirstNode, ...infer RestNodes] ? FirstNode extends Ast.Node ? RestNodes extends Ast.Node[] ? ProcessNode<ClientOptions, Schema, Row, RelationName, Relationships, FirstNode> extends infer FieldResult ? FieldResult extends Record<string, unknown> ? ProcessNodes<ClientOptions, Schema, Row, RelationName, Relationships, RestNodes, Acc & FieldResult> : FieldResult extends SelectQueryError<infer E> ? SelectQueryError<E> : SelectQueryError<'Could not retrieve a valid record or error value'> : SelectQueryError<'Processing node failed.'> : SelectQueryError<'Invalid rest nodes array type in ProcessNodes'> : SelectQueryError<'Invalid first node type in ProcessNodes'> : Prettify<Acc> : Prettify<CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes>>;
-/**
- * Processes a single Node and returns the resulting TypeScript type.
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param NodeType - The Node to process.
- */
-type ProcessNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], NodeType extends Ast.Node> = NodeType['type'] extends Ast.StarNode['type'] ? GetComputedFields<Schema, RelationName> extends never ? Row : Omit<Row, GetComputedFields<Schema, RelationName>> : NodeType['type'] extends Ast.SpreadNode['type'] ? ProcessSpreadNode<ClientOptions, Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.SpreadNode>> : NodeType['type'] extends Ast.FieldNode['type'] ? ProcessFieldNode<ClientOptions, Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.FieldNode>> : SelectQueryError<'Unsupported node type.'>;
-/**
- * Processes a FieldNode and returns the resulting TypeScript type.
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param Field - The FieldNode to process.
- */
-type ProcessFieldNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Field extends Ast.FieldNode> = Field['children'] extends [] ? ProcessEmbeddedResource<ClientOptions, Schema, Relationships, Field, RelationName> : IsNonEmptyArray<Field['children']> extends true ? ProcessEmbeddedResource<ClientOptions, Schema, Relationships, Field, RelationName> : ProcessSimpleField<Row, RelationName, Field>;
-type ResolveJsonPathType<Value, Path extends string | undefined, CastType extends PostgreSQLTypes> = Path extends string ? JsonPathToType<Value, Path> extends never ? TypeScriptTypes<CastType> : JsonPathToType<Value, Path> extends infer PathResult ? PathResult extends string ? PathResult : IsStringUnion<PathResult> extends true ? PathResult : CastType extends 'json' ? PathResult : TypeScriptTypes<CastType> : TypeScriptTypes<CastType> : TypeScriptTypes<CastType>;
-/**
- * Processes a simple field (without embedded resources).
- *
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Field - The FieldNode to process.
- */
-type ProcessSimpleField<Row extends Record<string, unknown>, RelationName extends string, Field extends Ast.FieldNode> = Field['name'] extends keyof Row | 'count' ? Field['aggregateFunction'] extends AggregateFunctions ? {
-    [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes ? TypeScriptTypes<Field['castType']> : number;
-} : {
-    [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes ? ResolveJsonPathType<Row[Field['name']], Field['jsonPath'], Field['castType']> : Row[Field['name']];
-} : SelectQueryError<`column '${Field['name']}' does not exist on '${RelationName}'.`>;
-/**
- * Processes an embedded resource (relation).
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param Field - The FieldNode to process.
- */
-type ProcessEmbeddedResource<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews$1<Schema> & string> = ResolveRelationship<Schema, Relationships, Field, CurrentTableOrView> extends infer Resolved ? Resolved extends {
-    scalarType: infer ScalarType;
-    relation: {
-        isSetofReturn?: boolean;
-        isNotNullable?: boolean;
-    };
-} ? {
-    [K in GetFieldNodeResultName<Field>]: Resolved['relation']['isSetofReturn'] extends true ? ScalarType : Resolved['relation']['isNotNullable'] extends true ? ScalarType : ScalarType | null;
-} : Resolved extends {
-    referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>;
-    relation: GenericRelationship & {
-        match: 'refrel' | 'col' | 'fkname' | 'func';
-    };
-    direction: string;
-} ? Field['children'] extends [] ? {} : ProcessEmbeddedResourceResult<ClientOptions, Schema, Resolved, Field, CurrentTableOrView> : {
-    [K in GetFieldNodeResultName<Field>]: Resolved;
-} : {
-    [K in GetFieldNodeResultName<Field>]: SelectQueryError<'Failed to resolve relationship.'> & string;
-};
-/**
- * Helper type to process the result of an embedded resource.
- */
-type ProcessEmbeddedResourceResult<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Resolved extends {
-    referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>;
-    relation: GenericRelationship & {
-        match: 'refrel' | 'col' | 'fkname' | 'func';
-        isNotNullable?: boolean;
-        referencedRelation: string;
-        isSetofReturn?: boolean;
-    };
-    direction: string;
-}, Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews$1<Schema>> = ProcessNodes<ClientOptions, Schema, Resolved['referencedTable']['Row'], Resolved['relation']['match'] extends 'func' ? Resolved['relation']['referencedRelation'] : Field['name'], Resolved['referencedTable']['Relationships'], Field['children'] extends undefined ? [] : Exclude<Field['children'], undefined> extends Ast.Node[] ? Exclude<Field['children'], undefined> : []> extends infer ProcessedChildren ? {
-    [K in GetFieldNodeResultName<Field>]: Resolved['direction'] extends 'forward' ? Field extends {
-        innerJoin: true;
-    } ? Resolved['relation']['isOneToOne'] extends true ? ProcessedChildren : ProcessedChildren[] : Resolved['relation']['isOneToOne'] extends true ? Resolved['relation']['match'] extends 'func' ? Resolved['relation']['isNotNullable'] extends true ? Resolved['relation']['isSetofReturn'] extends true ? ProcessedChildren : {
-        [P in keyof ProcessedChildren]: ProcessedChildren[P] | null;
-    } : ProcessedChildren | null : ProcessedChildren | null : ProcessedChildren[] : Resolved['relation']['referencedRelation'] extends CurrentTableOrView ? Resolved['relation']['match'] extends 'col' ? IsRelationNullable<TablesAndViews$1<Schema>[CurrentTableOrView], Resolved['relation']> extends true ? ProcessedChildren | null : ProcessedChildren : ProcessedChildren[] : IsRelationNullable<TablesAndViews$1<Schema>[CurrentTableOrView], Resolved['relation']> extends true ? Field extends {
-        innerJoin: true;
-    } ? ProcessedChildren : ProcessedChildren | null : ProcessedChildren;
-} : {
-    [K in GetFieldNodeResultName<Field>]: SelectQueryError<'Failed to process embedded resource nodes.'> & string;
-};
-/**
- * Processes a SpreadNode by processing its target node.
- *
- * @param Schema - Database schema.
- * @param Row - The type of a row in the current table.
- * @param RelationName - The name of the current table or view.
- * @param Relationships - Relationships of the current table.
- * @param Spread - The SpreadNode to process.
- */
-type ProcessSpreadNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Spread extends Ast.SpreadNode> = ProcessNode<ClientOptions, Schema, Row, RelationName, Relationships, Spread['target']> extends infer Result ? Result extends SelectQueryError<infer E> ? SelectQueryError<E> : ExtractFirstProperty<Result> extends unknown[] ? SpreadOnManyEnabled<ClientOptions['PostgrestVersion']> extends true ? ProcessManyToManySpreadNodeResult<Result> : {
-    [K in Spread['target']['name']]: SelectQueryError<`"${RelationName}" and "${Spread['target']['name']}" do not form a many-to-one or one-to-one relationship spread not possible`>;
-} : ProcessSpreadNodeResult<Result> : never;
-/**
- * Helper type to process the result of a many-to-many spread node.
- * Converts all fields in the spread object into arrays.
- */
-type ProcessManyToManySpreadNodeResult<Result> = Result extends Record<string, SelectQueryError<string> | null> ? Result : ExtractFirstProperty<Result> extends infer SpreadedObject ? SpreadedObject extends Array<Record<string, unknown>> ? {
-    [K in keyof SpreadedObject[number]]: Array<SpreadedObject[number][K]>;
-} : SelectQueryError<'An error occurred spreading the many-to-many object'> : SelectQueryError<'An error occurred spreading the many-to-many object'>;
-/**
- * Helper type to process the result of a spread node.
- */
-type ProcessSpreadNodeResult<Result> = Result extends Record<string, SelectQueryError<string> | null> ? Result : ExtractFirstProperty<Result> extends infer SpreadedObject ? ContainsNull<SpreadedObject> extends true ? Exclude<{
-    [K in keyof SpreadedObject]: SpreadedObject[K] | null;
-}, null> : Exclude<{
-    [K in keyof SpreadedObject]: SpreadedObject[K];
-}, null> : SelectQueryError<'An error occurred spreading the object'>;
-
-/**
- * `ClientOptions` figé pour aurabase — PostgREST v12. Satisfait `ClientServerOptions`
- * et sert de défaut au threading de types (pas de configuration exposée côté SDK).
- */
-type AuraClientOptionsT = {
-    PostgrestVersion: '12';
-};
-interface StoredFilter {
-    column: string;
-    op: string;
-    value: unknown;
-}
-interface OrGroup {
-    filters: StoredFilter[];
-}
-type MutationMode = {
-    type: 'insert';
-    body: unknown;
-} | {
-    type: 'update';
-    id: string | null;
-    body: unknown;
-} | {
-    type: 'delete';
-    id: string | null;
-} | {
-    type: 'upsert';
-    body: unknown;
-    onConflict: string;
-};
-/** État d'un builder en mode `rpc` (`DatabaseService.rpc()`) : args + verbe HTTP. */
-type RpcMode = {
-    args: unknown;
-    verb: 'POST' | 'GET' | 'HEAD';
-};
-/**
- * Base class : état partagé, constructeur, exécution HTTP (`then`/`_execute`),
- * `throwOnError` et `buildQueryString`. Implements PromiseLike so it can be
- * awaited directly.
- */
-declare class AuraPostgrestBuilder<ClientOptions extends ClientServerOptions = AuraClientOptionsT, Result = Record<string, unknown>, ThrowOnError extends boolean = false> implements PromiseLike<AuraResponse<Result>> {
-    protected readonly _client: AuraClientLike;
-    protected readonly _basePath: string;
-    protected _filters: StoredFilter[];
-    protected _orGroups: OrGroup[];
-    protected _selectColumns: string[] | null;
-    protected _selectInvoked: boolean;
-    protected _sortColumn: string | null;
-    protected _sortDirection: 'asc' | 'desc';
-    protected _limit: number | null;
-    protected _offset: number | null;
-    protected _cursor: string | null;
-    protected _count: CountMode | null;
-    protected _rawSelect: boolean;
-    protected _single: boolean;
-    protected _maybeSingle: boolean;
-    protected _throwOnError: boolean;
-    protected _mutation: MutationMode | null;
-    protected _rpc: RpcMode | null;
-    constructor(client: AuraClientLike, basePath: string);
-    throwOnError(): this;
-    /**
-     * Positionne l'état interne `rpc` (args + verbe HTTP) — méthode package-interne
-     * utilisée par `DatabaseService.rpc()` pour éviter un cast sur un champ `protected`.
-     *
-     * `count` accepte `'planned'` (parité stricte `RpcOptions`, cf. `DatabaseService.rpc`)
-     * en plus de `CountMode` (`@aurabase/core`, qui ne connaît que `exact`/`estimated` —
-     * package partagé, non modifié ici). Le cast vers `_count` reste sans risque runtime :
-     * `buildQueryString` sérialise la valeur telle quelle en query param `count=`.
-     */
-    _initRpc(args: unknown, verb: 'POST' | 'GET' | 'HEAD', count?: 'exact' | 'planned' | 'estimated'): this;
-    buildQueryString(): string;
-    then<TResult1 = AuraResponse<Result>, TResult2 = never>(onfulfilled?: ((value: AuraResponse<Result>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    private _execute;
-}
-/**
- * Sélection de colonnes, tri, pagination et modificateurs de cardinalité
- * (`single`/`maybeSingle`/`count`).
- */
-declare class AuraTransformBuilder<Schema extends GenericSchema = GenericSchema, Row extends Record<string, unknown> = Record<string, unknown>, RelationName = unknown, Relationships = unknown, Result = Record<string, unknown>, ClientOptions extends ClientServerOptions = AuraClientOptionsT, ThrowOnError extends boolean = false> extends AuraPostgrestBuilder<ClientOptions, Result, ThrowOnError> {
-    /**
-     * Select columns and optionally embed related resources (PostgREST parity).
-     *
-     * @example
-     * // Simple columns
-     * db.from('users').select('id, name, email')
-     *
-     * // All columns (default)
-     * db.from('users').select('*')
-     *
-     * // Embed related table (many-to-one)
-     * db.from('orders').select('*, customer:customers(name, email)')
-     *
-     * // Embed related table (one-to-many)
-     * db.from('directors').select('last_name, films(title, year)')
-     *
-     * // FK disambiguation
-     * db.from('orders').select('*, billing:addresses!billing_address_id(name)')
-     *
-     * // Nested embedding
-     * db.from('actors').select('first_name, roles(character, films(title))')
-     */
-    select<Query extends string = '*', NewResultOne = GetResult<Schema, Row, RelationName, Relationships, Query, ClientOptions>>(columns?: Query): AuraFilterBuilder<Schema, Row, RelationName, Relationships, NewResultOne[], ClientOptions, ThrowOnError>;
-    order(column: string, direction?: 'asc' | 'desc'): this;
-    limit(n: number): this;
-    offset(n: number): this;
-    /**
-     * Pagination keyset : passer le `next_cursor` opaque de la page précédente (préférable à
-     * `offset` sur les grandes tables : stable, sans dup/skip). Renvoyer tel quel `meta.next_cursor` ;
-     * ne pas le construire/parser (format opaque).
-     */
-    cursor(cursor: string): this;
-    count(mode?: CountMode): this;
-    single<ResultOne = Result extends (infer U)[] ? U : Result>(): AuraPostgrestBuilder<ClientOptions, ResultOne, ThrowOnError>;
-    maybeSingle<ResultOne = Result extends (infer U)[] ? U : Result>(): AuraPostgrestBuilder<ClientOptions, ResultOne | null, ThrowOnError>;
-}
-/**
- * Tous les filtres PostgREST (`eq`, `neq`, ... `ilikeAnyOf`).
- */
-declare class AuraFilterBuilder<Schema extends GenericSchema = GenericSchema, Row extends Record<string, unknown> = Record<string, unknown>, RelationName = unknown, Relationships = unknown, Result = Record<string, unknown>, ClientOptions extends ClientServerOptions = AuraClientOptionsT, ThrowOnError extends boolean = false> extends AuraTransformBuilder<Schema, Row, RelationName, Relationships, Result, ClientOptions, ThrowOnError> {
-    eq<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    neq<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    gt<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    gte<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    lt<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    lte<C extends keyof Row & string>(column: C, value: Row[C]): this;
-    like(column: keyof Row & string, pattern: string): this;
-    ilike(column: keyof Row & string, pattern: string): this;
-    /**
-     * IS NULL or IS NOT NULL filter.
-     * PostgREST accepts: is.null, is.true, is.false (no "not_null" — use neq for that).
-     * For IS NOT NULL, use `neq(column, null)` or `is(column, 'not.null')`.
-     */
-    is(column: keyof Row & string, value: 'null' | 'true' | 'false' | 'unknown' | 'not.null'): this;
-    in<C extends keyof Row & string>(column: C, values: Row[C][]): this;
-    /**
-     * Add an OR group: `or=(col1.eq.val1,col2.gt.val2)`
-     */
-    or(filters: Array<{
-        column: string;
-        op: string;
-        value: unknown;
-    }>): this;
-    notIn<C extends keyof Row & string>(column: C, values: Row[C][]): this;
-    contains(column: keyof Row & string, value: unknown): this;
-    containedBy(column: keyof Row & string, value: unknown): this;
-    overlaps(column: keyof Row & string, value: unknown): this;
-    rangeGt(column: keyof Row & string, range: string): this;
-    rangeGte(column: keyof Row & string, range: string): this;
-    rangeLt(column: keyof Row & string, range: string): this;
-    rangeLte(column: keyof Row & string, range: string): this;
-    rangeAdjacent(column: keyof Row & string, range: string): this;
-    isDistinct(column: keyof Row & string, value: unknown): this;
-    not(column: string, op: string, value: unknown): this;
-    filter(column: string, op: string, value: unknown): this;
-    match(query: Record<string, unknown>): this;
-    textSearch(column: keyof Row & string, query: string, options?: {
-        type?: 'plain' | 'phrase' | 'websearch';
-        config?: string;
-    }): this;
-    likeAllOf(column: keyof Row & string, patterns: string[]): this;
-    likeAnyOf(column: keyof Row & string, patterns: string[]): this;
-    ilikeAllOf(column: keyof Row & string, patterns: string[]): this;
-    ilikeAnyOf(column: keyof Row & string, patterns: string[]): this;
-}
-/**
- * Chainable query builder that compiles to URL query parameters
- * matching the backend's QueryOptions / FilterOp format.
- *
- * Point d'entrée concret retourné par `DatabaseService.from()` : ajoute les
- * mutations (`insert`/`update`/`delete`/`upsert`) au-dessus de la chaîne
- * Base → Transform → Filter.
- */
-declare class AuraQueryBuilder<Schema extends GenericSchema = GenericSchema, Relation extends GenericTable | GenericView = GenericTable, RelationName = unknown, ClientOptions extends ClientServerOptions = AuraClientOptionsT> extends AuraFilterBuilder<Schema, Relation['Row'], RelationName, Relation['Relationships'], Relation['Row'][], ClientOptions, false> {
-    insert(body: Relation extends {
-        Insert: infer I;
-    } ? I | I[] : never): this;
-    update(id: string, body: Relation extends {
-        Update: infer U;
-    } ? U : never): AuraFilterBuilder<Schema, Relation['Row'], RelationName, Relation['Relationships'], Relation['Row'][], ClientOptions, false>;
-    update(body: Relation extends {
-        Update: infer U;
-    } ? U : never): AuraFilterBuilder<Schema, Relation['Row'], RelationName, Relation['Relationships'], Relation['Row'][], ClientOptions, false>;
-    delete(id?: string): AuraFilterBuilder<Schema, Relation['Row'], RelationName, Relation['Relationships'], Relation['Row'][], ClientOptions, false>;
-    upsert(body: Relation extends {
-        Insert: infer I;
-    } ? I | I[] : never, options?: {
-        onConflict?: string;
-    }): AuraFilterBuilder<Schema, Relation['Row'], RelationName, Relation['Relationships'], Relation['Row'][], ClientOptions, false>;
-}
-
-type IsMatchingArgs<FnArgs extends GenericFunction['Args'], PassedArgs extends GenericFunction['Args']> = [FnArgs] extends [Record<PropertyKey, never>] ? PassedArgs extends Record<PropertyKey, never> ? true : false : keyof PassedArgs extends keyof FnArgs ? PassedArgs extends FnArgs ? true : false : false;
-type MatchingFunctionArgs<Fn extends GenericFunction, Args extends GenericFunction['Args']> = Fn extends {
-    Args: infer A extends GenericFunction['Args'];
-} ? IsMatchingArgs<A, Args> extends true ? Fn : never : false;
-type FindMatchingFunctionByArgs<FnUnion, Args extends GenericFunction['Args']> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false;
-type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
-type ExtractExactFunction<Fns, Args> = Fns extends infer F ? F extends GenericFunction ? ExactMatch<F['Args'], Args> extends true ? F : never : never : never;
-type IsNever<T> = [T] extends [never] ? true : false;
-type RpcFunctionNotFound<FnName> = {
-    Row: any;
-    Result: {
-        error: true;
-    } & "Couldn't infer function definition matching provided arguments";
-    RelationName: FnName;
-    Relationships: null;
-};
-type CrossSchemaError<TableRef extends string> = {
-    error: true;
-} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`;
-type GetRpcFunctionFilterBuilderByArgs<Schema extends GenericSchema, FnName extends string & keyof Schema['Functions'], Args> = {
-    0: Schema['Functions'][FnName];
-    1: IsAny<Schema> extends true ? any : IsNever<Args> extends true ? IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true ? LastOf<Schema['Functions'][FnName]> : ExtractExactFunction<Schema['Functions'][FnName], Args> : Args extends Record<PropertyKey, never> ? LastOf<Schema['Functions'][FnName]> : Args extends GenericFunction['Args'] ? IsNever<LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>> extends true ? LastOf<Schema['Functions'][FnName]> : LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>> : ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction ? ExtractExactFunction<Schema['Functions'][FnName], Args> : any;
-}[1] extends infer Fn ? IsAny<Fn> extends true ? {
-    Row: any;
-    Result: any;
-    RelationName: FnName;
-    Relationships: null;
-} : Fn extends GenericFunction ? {
-    Row: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema> ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row'] : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : CrossSchemaError<Fn['SetofOptions']['to'] & string> : Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : never : Fn['Returns'] extends Record<string, unknown> ? Fn['Returns'] : never;
-    Result: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['isSetofReturn'] extends true ? Fn['SetofOptions']['isOneToOne'] extends true ? Fn['Returns'][] : Fn['Returns'] : Fn['Returns'] : Fn['Returns'];
-    RelationName: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] : FnName;
-    Relationships: Fn['SetofOptions'] extends GenericSetofOption ? Fn['SetofOptions']['to'] extends keyof Schema['Tables'] ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships'] : Fn['SetofOptions']['to'] extends keyof Schema['Views'] ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships'] : null : null;
-} : Fn extends false ? RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName> : RpcFunctionNotFound<FnName>;
-
-interface RpcOptions {
-    count?: 'exact' | 'planned' | 'estimated';
-    head?: boolean;
-    get?: boolean;
-}
-type RpcArgsFor<Schema extends GenericSchema, FnName extends string> = [
-    Schema['Functions'][FnName]
-] extends [never] ? Record<string, unknown> : FnName extends keyof Schema['Functions'] ? Schema['Functions'][FnName]['Args'] : Record<string, unknown>;
-type RpcResultFor<Schema extends GenericSchema, FnName extends string, Args> = [
-    Schema['Functions'][FnName]
-] extends [never] ? {
-    Row: any;
-    Result: any;
-    RelationName: any;
-    Relationships: any;
-} : FnName extends string & keyof Schema['Functions'] ? GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args> : {
-    Row: any;
-    Result: any;
-    RelationName: any;
-    Relationships: any;
-};
-declare class DatabaseService<Database = any, Schema extends GenericSchema = Database extends {
-    public: infer S;
-} ? S extends GenericSchema ? S : any : any> extends BaseService {
-    constructor(client: AuraClientLike);
-    private get prefix();
-    /**
-     * Start a query on a table. Returns a chainable QueryBuilder dont `.select()`
-     * infère son type de résultat via `GetResult` (parité PostgREST/Supabase) quand
-     * un `Database` typé est fourni à `createClient<Database>()`.
-     *
-     * @example
-     * const { data, error } = await db.from('posts').eq('published', true).limit(10)
-     */
-    from<TableName extends string & keyof Schema['Tables'], Table extends Schema['Tables'][TableName]>(table: TableName): AuraQueryBuilder<Schema, Table, TableName, AuraClientOptionsT>;
-    from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(view: ViewName): AuraQueryBuilder<Schema, View, ViewName, AuraClientOptionsT>;
-    from(table: string): AuraQueryBuilder<any, any, any, AuraClientOptionsT>;
-    /**
-     * Exécute une requête SQL brute (passthrough direct vers Postgres).
-     *
-     * ⚠️ N'est PAS en lecture seule : SELECT, INSERT, UPDATE, DELETE et DDL
-     * s'exécutent réellement et persistent, dans la limite des GRANTs du rôle
-     * Postgres connecté pour ce projet (seule barrière de sécurité — il n'y a
-     * aucun filtre applicatif par type d'instruction côté serveur). Ne pas
-     * exposer cet endpoint sans restriction à des clients non fiables.
-     */
-    sql<T = unknown>(query: string, params?: unknown[]): Promise<AuraResponse<T>>;
-    /**
-     * Appelle une fonction Postgres exposée par PostgREST (`POST|GET|HEAD /rpc/{fn}`).
-     * Signature forte quand `Schema['Functions']` connaît `fn` (typage vendoré
-     * `GetRpcFunctionFilterBuilderByArgs`, parité postgrest-js) ; sinon repli permissif.
-     *
-     * @example
-     * const { data } = await db.rpc('add', { a: 1, b: 2 })
-     * const { data } = await db.rpc('list_things', {}).eq('id', 2).select('id,name').single()
-     */
-    rpc<FnName extends string, Args extends RpcArgsFor<Schema, FnName> = RpcArgsFor<Schema, FnName>, Fn extends {
-        Row: any;
-        Result: any;
-        RelationName: any;
-        Relationships: any;
-    } = RpcResultFor<Schema, FnName, Args>>(fn: FnName, args?: Args, options?: RpcOptions): AuraFilterBuilder<Schema, Fn['Row'], Fn['RelationName'], Fn['Relationships'], Fn['Result'], AuraClientOptionsT>;
-    /**
-     * Fetch the schema (tables & colonnes, fonctions Postgres exposées via PostgREST,
-     * types enum et vues) pour le projet courant.
-     */
-    schema(): Promise<AuraResponse<{
-        tables: SchemaTable[];
-        functions: SchemaFunction[];
-        enums: SchemaEnum[];
-        views: SchemaTable[];
-    }>>;
-}
-
-export { DatabaseService, AuraQueryBuilder as QueryBuilder };