import { AnyFromSource, SelectAst } from "@prisma-next/sql-relational-core/ast";
import { CodecExpression, CodecTypesBase, Expression as Expression$1, RawSqlTag, ScopeField, TraitExpression } from "@prisma-next/sql-relational-core/expression";
import { AnnotationValue, OperationKind, ValidAnnotations } from "@prisma-next/framework-components/runtime";
import { ExtractCodecTypes, ExtractQueryOperationTypes, ExtractStorageColumnInputTypes, ExtractStorageColumnTypes, QueryOperationTypesBase, StorageColumnMapAt, StorageTable, StorageTable as StorageTable$1 } from "@prisma-next/sql-contract/types";
import { SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
//#region src/scope.d.ts
type GatedMethod<Capabilities, Required, Method> = Capabilities extends Required ? Method : never;
declare const JoinOuterScope: unique symbol;
declare const SubqueryMarker: unique symbol;
type Expand<T> = { [K in keyof T]: T[K]; } & unknown;
type EmptyRow = Record<never, ScopeField>;
type ScopeTable = Record<string, ScopeField>;
type Scope = {
  topLevel: ScopeTable;
  namespaces: Record<string, ScopeTable>;
};
type JoinSource<Row extends ScopeTable, Alias extends string> = {
  readonly [JoinOuterScope]: {
    topLevel: Row;
    namespaces: Record<Alias, Row>;
  };
  getJoinOuterScope(): Scope;
  buildAst(): AnyFromSource;
};
type DefaultScope<Name extends string, Table extends StorageTable$1> = {
  topLevel: StorageTableToScopeTable<Table>;
  namespaces: { [K in Name]: StorageTableToScopeTable<Table>; };
};
type StorageTableToScopeTable<T extends StorageTable$1> = { [K in keyof T['columns']]: {
  codecId: T['columns'][K]['codecId'];
  nullable: T['columns'][K]['nullable'];
} & (T['columns'][K] extends {
  many: true;
} ? {
  many: true;
} : Record<never, never>); };
type MergeScopes<A extends Scope, B extends Scope> = {
  topLevel: Expand<Omit<A['topLevel'], keyof B['topLevel']> & Omit<B['topLevel'], keyof A['topLevel']>>;
  namespaces: Expand<A['namespaces'] & B['namespaces']>;
};
type RebindScope<S extends Scope, OldKey extends string, NewKey extends string> = {
  topLevel: S['topLevel'];
  namespaces: Expand<Omit<S['namespaces'], OldKey> & Record<NewKey, S['namespaces'][OldKey]>>;
};
type NullableScopeTable<S extends ScopeTable> = { [K in keyof S]: {
  codecId: S[K]['codecId'];
  nullable: true;
}; };
type NullableScope<S extends Scope> = {
  topLevel: NullableScopeTable<S['topLevel']>;
  namespaces: { [TableName in keyof S['namespaces']]: NullableScopeTable<S['namespaces'][TableName]>; };
};
type Subquery<RowType extends Record<string, ScopeField>> = {
  [SubqueryMarker]: RowType;
  buildAst(): SelectAst;
  getRowFields(): Record<string, ScopeField>;
};
type QueryContext = {
  readonly codecTypes: CodecTypesBase;
  readonly capabilities: Record<string, Record<string, boolean>>;
  readonly queryOperationTypes: QueryOperationTypesBase;
  readonly resolvedColumnOutputTypes: Record<string, unknown>;
};
//#endregion
//#region src/expression.d.ts
type BooleanCodecType = {
  codecId: 'pg/bool@1';
  nullable: boolean;
};
type WithField<Source, Field extends ScopeField, Alias extends string> = Expand<Source & { [K in Alias]: Field; }>;
type WithFields<Source, FromScope extends ScopeTable, Columns extends readonly (keyof FromScope)[]> = Expand<Source & Pick<FromScope, Columns[number]>>;
type ExtractScopeFields<T extends Record<string, Expression$1<ScopeField>>> = { [K in keyof T]: T[K] extends Expression$1<infer F extends ScopeField> ? F : never; };
type FieldProxy<AvailableScope extends Scope> = { [K in keyof AvailableScope['topLevel']]: Expression$1<AvailableScope['topLevel'][K]>; } & { [TableName in keyof AvailableScope['namespaces']]: { [K in keyof AvailableScope['namespaces'][TableName]]: Expression$1<AvailableScope['namespaces'][TableName][K]>; }; };
type ExpressionBuilder<AvailableScope extends Scope, QC extends QueryContext> = (fields: FieldProxy<AvailableScope>, fns: Functions<QC>) => Expression$1<BooleanCodecType>;
type OrderByDirection = 'asc' | 'desc';
type OrderByNulls = 'first' | 'last';
type OrderByOptions = {
  direction?: OrderByDirection;
  nulls?: OrderByNulls;
};
type OrderByScope<AvailableScope extends Scope, RowType extends Record<string, ScopeField>> = {
  topLevel: Expand<AvailableScope['topLevel'] & RowType>;
  namespaces: AvailableScope['namespaces'];
};
type DeriveExtFunctions<OT extends QueryOperationTypesBase> = { [K in keyof OT]: OT[K]['impl']; };
type BuiltinFunctions<CT extends Record<string, {
  readonly input: unknown;
}>> = {
  eq: <CodecId extends string>(a: CodecExpression<CodecId, boolean, CT> | null, b: CodecExpression<CodecId, boolean, CT> | null) => Expression$1<BooleanCodecType>;
  ne: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT> | null, b: CodecExpression<CodecId, N, CT> | null) => Expression$1<BooleanCodecType>;
  gt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression$1<BooleanCodecType>;
  gte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression$1<BooleanCodecType>;
  lt: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression$1<BooleanCodecType>;
  lte: <CodecId extends string, N extends boolean>(a: CodecExpression<CodecId, N, CT>, b: CodecExpression<CodecId, N, CT>) => Expression$1<BooleanCodecType>;
  and: (...ands: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression$1<BooleanCodecType>;
  or: (...ors: CodecExpression<'pg/bool@1', boolean, CT>[]) => Expression$1<BooleanCodecType>;
  exists: (subquery: Subquery<Record<string, ScopeField>>) => Expression$1<BooleanCodecType>;
  notExists: (subquery: Subquery<Record<string, ScopeField>>) => Expression$1<BooleanCodecType>;
  in: {
    <CodecId extends string>(expr: Expression$1<{
      codecId: CodecId;
      nullable: boolean;
    }>, subquery: Subquery<Record<string, {
      codecId: CodecId;
      nullable: boolean;
    }>>): Expression$1<BooleanCodecType>;
    <CodecId extends string>(expr: Expression$1<{
      codecId: CodecId;
      nullable: boolean;
    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression$1<BooleanCodecType>;
  };
  notIn: {
    <CodecId extends string>(expr: Expression$1<{
      codecId: CodecId;
      nullable: boolean;
    }>, subquery: Subquery<Record<string, {
      codecId: CodecId;
      nullable: boolean;
    }>>): Expression$1<BooleanCodecType>;
    <CodecId extends string>(expr: Expression$1<{
      codecId: CodecId;
      nullable: boolean;
    }>, values: Array<CodecExpression<CodecId, boolean, CT>>): Expression$1<BooleanCodecType>;
  };
  readonly raw: RawSqlTag;
};
type Functions<QC extends QueryContext> = BuiltinFunctions<QC['codecTypes']> & DeriveExtFunctions<QC['queryOperationTypes']>;
type CountField = {
  codecId: 'pg/int8@1';
  nullable: false;
};
type AggregateOnlyFunctions = {
  count: (expr?: Expression$1<ScopeField>) => Expression$1<CountField>;
  sum: <T extends ScopeField>(expr: Expression$1<T>) => Expression$1<{
    codecId: T['codecId'];
    nullable: true;
  }>;
  avg: <T extends ScopeField>(expr: Expression$1<T>) => Expression$1<{
    codecId: T['codecId'];
    nullable: true;
  }>;
  min: <T extends ScopeField>(expr: Expression$1<T>) => Expression$1<{
    codecId: T['codecId'];
    nullable: true;
  }>;
  max: <T extends ScopeField>(expr: Expression$1<T>) => Expression$1<{
    codecId: T['codecId'];
    nullable: true;
  }>;
};
type AggregateFunctions<QC extends QueryContext> = Functions<QC> & AggregateOnlyFunctions;
//#endregion
//#region src/resolve.d.ts
type ResolveField<F extends ScopeField, CodecTypes extends Record<string, {
  readonly output: unknown;
}>> = F['codecId'] extends keyof CodecTypes ? F['nullable'] extends true ? CodecTypes[F['codecId']]['output'] | null : CodecTypes[F['codecId']]['output'] : unknown;
type ApplyNullable<T, F extends ScopeField> = F['nullable'] extends true ? T | null : T;
type ResolveRow<Row extends Record<string, ScopeField>, CodecTypes extends Record<string, {
  readonly output: unknown;
}>, PreResolved extends Record<string, unknown> = Record<string, never>> = Expand<{ -readonly [K in keyof Row]: string extends keyof PreResolved ? ResolveField<Row[K], CodecTypes> : K extends keyof PreResolved ? ApplyNullable<NonNullable<PreResolved[K & keyof PreResolved]>, Row[K]> : ResolveField<Row[K], CodecTypes>; }>;
//#endregion
//#region src/types/mutation-query.d.ts
type ReturningCapability = {
  sql: {
    returning: true;
  };
};
type InsertValues<Table extends StorageTable, CT extends Record<string, {
  readonly input: unknown;
}>> = { [K in keyof Table['columns']]?: Table['columns'][K]['codecId'] extends keyof CT ? CT[Table['columns'][K]['codecId']]['input'] : unknown; };
interface InsertQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
  /**
   * Attach one or more write-typed annotations to this query plan.
   * Annotations declare `applicableTo: ['write']` (or `['read', 'write']`)
   * via `defineAnnotation`; read-only annotations fail to compile here.
   * Annotations are merged into `plan.meta.annotations` at `.build()` time.
   * Chainable in any position; multiple calls compose with last-write-wins
   * on duplicate namespaces.
   */
  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): InsertQuery<QC, AvailableScope, RowType>;
  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => InsertQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
}
interface UpdateQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
  /**
   * Attach one or more write-typed annotations to this query plan.
   * See `InsertQuery.annotate` for semantics.
   */
  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): UpdateQuery<QC, AvailableScope, RowType>;
  where(expr: ExpressionBuilder<AvailableScope, QC>): UpdateQuery<QC, AvailableScope, RowType>;
  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => UpdateQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
}
interface DeleteQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> {
  /**
   * Attach one or more write-typed annotations to this query plan.
   * See `InsertQuery.annotate` for semantics.
   */
  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'write', As>): DeleteQuery<QC, AvailableScope, RowType>;
  where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType>;
  returning: GatedMethod<QC['capabilities'], ReturningCapability, <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns) => DeleteQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>>;
  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
}
//#endregion
//#region src/types/joined-tables.d.ts
interface JoinedTables<QC extends QueryContext, AvailableScope extends Scope> extends WithSelect<QC, AvailableScope, EmptyRow>, WithJoin<QC, AvailableScope, QC['capabilities']> {}
//#endregion
//#region src/types/grouped-query.d.ts
interface GroupedQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> extends Subquery<RowType>, WithPagination<QC>, WithDistinct, WithAlias<RowType>, WithBuild<QC, RowType> {
  /**
   * Attach one or more read-typed annotations to this query plan.
   * Annotations declare `applicableTo: ['read']` (or `['read', 'write']`)
   * via `defineAnnotation`; write-only annotations fail to compile here.
   * Annotations are merged into `plan.meta.annotations` at `.build()` time.
   * Chainable in any position; multiple calls compose with last-write-wins
   * on duplicate namespaces.
   */
  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'read', As>): GroupedQuery<QC, AvailableScope, RowType>;
  groupBy(...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
  groupBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression$1<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
  having(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: AggregateFunctions<QC>) => Expression$1<BooleanCodecType>): GroupedQuery<QC, AvailableScope, RowType>;
  orderBy(field: (keyof RowType | keyof AvailableScope['topLevel']) & string, options?: OrderByOptions): GroupedQuery<QC, AvailableScope, RowType>;
  orderBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: AggregateFunctions<QC>) => Expression$1<ScopeField>, options?: OrderByOptions): GroupedQuery<QC, AvailableScope, RowType>;
  distinctOn: GatedMethod<QC['capabilities'], {
    postgres: {
      distinctOn: true;
    };
  }, {
    (...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
    (expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression$1<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
  }>;
}
//#endregion
//#region src/types/select-query.d.ts
interface SelectQuery<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField>> extends Subquery<RowType>, WithSelect<QC, AvailableScope, RowType>, WithPagination<QC>, WithDistinct, WithAlias<RowType>, WithBuild<QC, RowType> {
  /**
   * Attach one or more read-typed annotations to this query plan.
   * Annotations declare `applicableTo: ['read']` (or `['read', 'write']`)
   * via `defineAnnotation`; write-only annotations fail to compile here.
   * Annotations are merged into `plan.meta.annotations` at `.build()` time.
   * Chainable in any position; multiple calls compose with last-write-wins
   * on duplicate namespaces.
   */
  annotate<As extends readonly AnnotationValue<unknown, OperationKind>[]>(...annotations: As & ValidAnnotations<'read', As>): SelectQuery<QC, AvailableScope, RowType>;
  where(expr: ExpressionBuilder<AvailableScope, QC>): SelectQuery<QC, AvailableScope, RowType>;
  orderBy(field: (keyof RowType | keyof AvailableScope['topLevel']) & string, options?: OrderByOptions): SelectQuery<QC, AvailableScope, RowType>;
  orderBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression$1<ScopeField>, options?: OrderByOptions): SelectQuery<QC, AvailableScope, RowType>;
  groupBy(...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): GroupedQuery<QC, AvailableScope, RowType>;
  groupBy(expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression$1<ScopeField>): GroupedQuery<QC, AvailableScope, RowType>;
  distinctOn: GatedMethod<QC['capabilities'], {
    postgres: {
      distinctOn: true;
    };
  }, {
    (...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]): SelectQuery<QC, AvailableScope, RowType>;
    (expr: (fields: FieldProxy<OrderByScope<AvailableScope, RowType>>, fns: Functions<QC>) => Expression$1<ScopeField>): SelectQuery<QC, AvailableScope, RowType>;
  }>;
}
//#endregion
//#region src/types/shared.d.ts
interface LateralBuilder<QC extends QueryContext, ParentScope extends Scope> {
  from<Other extends JoinSource<ScopeTable, string | never>>(other: Other): SelectQuery<QC, MergeScopes<ParentScope, Other[typeof JoinOuterScope]>, EmptyRow>;
}
interface WithSelect<QC extends QueryContext, AvailableScope extends Scope, RowType extends Record<string, ScopeField> = EmptyRow> {
  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(...columns: Columns): SelectQuery<QC, AvailableScope, WithFields<RowType, AvailableScope['topLevel'], Columns>>;
  select<Alias extends string, Field extends ScopeField>(alias: Alias, expr: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Expression$1<Field>): SelectQuery<QC, AvailableScope, WithField<RowType, Field, Alias>>;
  select<Result extends Record<string, Expression$1<ScopeField>>>(callback: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Result): SelectQuery<QC, AvailableScope, Expand<RowType & ExtractScopeFields<Result>>>;
}
interface WithJoin<QC extends QueryContext, AvailableScope extends Scope, Capabilities> {
  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>>;
  outerLeftJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<Other[typeof JoinOuterScope]>>>;
  outerRightJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, Other[typeof JoinOuterScope]>>;
  outerFullJoin<Other extends JoinSource<ScopeTable, string | never>>(other: Other, on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, NullableScope<Other[typeof JoinOuterScope]>>>;
  lateralJoin: GatedMethod<Capabilities, {
    sql: {
      lateral: true;
    };
  }, <Alias extends string, LateralRow extends Record<string, ScopeField>>(alias: Alias, builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>) => JoinedTables<QC, MergeScopes<AvailableScope, {
    topLevel: LateralRow;
    namespaces: Record<Alias, LateralRow>;
  }>>>;
  outerLateralJoin: GatedMethod<Capabilities, {
    sql: {
      lateral: true;
    };
  }, <Alias extends string, LateralRow extends Record<string, ScopeField>>(alias: Alias, builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>) => JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<{
    topLevel: LateralRow;
    namespaces: Record<Alias, LateralRow>;
  }>>>>;
}
type PaginationValue<QC extends QueryContext> = number | TraitExpression<readonly ['numeric'], false, QC['codecTypes']>;
interface WithPagination<QC extends QueryContext> {
  limit(count: PaginationValue<QC>): this;
  offset(count: PaginationValue<QC>): this;
}
interface WithDistinct {
  distinct(): this;
}
interface WithAlias<RowType extends Record<string, ScopeField>> {
  as<Alias extends string>(newAlias: Alias): JoinSource<RowType, Alias>;
}
interface WithBuild<QC extends QueryContext, RowType extends Record<string, ScopeField>> {
  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes'], QC['resolvedColumnOutputTypes']>>;
}
//#endregion
//#region src/types/table-proxy.d.ts
type ResolvedColumnTypes<C extends TableProxyContract, NsId extends string, TableName extends string, ColMap = StorageColumnMapAt<ExtractStorageColumnTypes<C>, NsId, TableName>, ColumnKeys extends string = [ColMap] extends [never] ? never : keyof ColMap & string> = { readonly [K in ColumnKeys]: ColMap extends Record<K, unknown> ? ColMap[K] : never; };
type ResolvedInsertValues<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, CT extends Record<string, {
  readonly input: unknown;
}>> = StorageColumnMapAt<ExtractStorageColumnInputTypes<C>, NsId, TableName> extends (infer ColMap) ? [ColMap] extends [never] ? InsertValues<Table, CT> : { [K in keyof ColMap]?: ColMap[K]; } : InsertValues<Table, CT>;
type ResolvedUpdateValues<C extends TableProxyContract, NsId extends string, Table extends StorageTable, TableName extends string, CT extends Record<string, {
  readonly input: unknown;
}>> = ResolvedInsertValues<C, NsId, Table, TableName, CT>;
type ResolvedUpdateExpressions<Table extends StorageTable> = { [K in keyof Table['columns']]?: Expression$1<{
  codecId: Table['columns'][K]['codecId'];
  nullable: boolean;
}>; };
type ContractToQC<C extends TableProxyContract, NsId extends string = string, Name extends string = string> = {
  readonly codecTypes: ExtractCodecTypes<C>;
  readonly capabilities: C['capabilities'];
  readonly queryOperationTypes: ExtractQueryOperationTypes<C>;
  readonly resolvedColumnOutputTypes: ResolvedColumnTypes<C, NsId, Name>;
};
interface TableProxy<C extends TableProxyContract, NsId extends string, Name extends string, Alias extends string = Name, AvailableScope extends Scope = DefaultScope<Name, NamespaceTable<C, NsId, Name>>, QC extends QueryContext = ContractToQC<C, NsId, Name>> extends JoinSource<StorageTableToScopeTable<NamespaceTable<C, NsId, Name>>, Alias>, WithSelect<QC, AvailableScope, EmptyRow>, WithJoin<QC, AvailableScope, C['capabilities']> {
  as<NewAlias extends string>(newAlias: NewAlias): TableProxy<C, NsId, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC>;
  insert(rows: ReadonlyArray<ResolvedInsertValues<C, NsId, NamespaceTable<C, NsId, Name>, Name, QC['codecTypes']>>): InsertQuery<QC, AvailableScope, EmptyRow>;
  update(set: ResolvedUpdateValues<C, NsId, NamespaceTable<C, NsId, Name>, Name, QC['codecTypes']>): UpdateQuery<QC, AvailableScope, EmptyRow>;
  update(callback: (fields: FieldProxy<AvailableScope>, fns: Functions<QC>) => ResolvedUpdateExpressions<NamespaceTable<C, NsId, Name>>): UpdateQuery<QC, AvailableScope, EmptyRow>;
  delete(): DeleteQuery<QC, AvailableScope, EmptyRow>;
}
//#endregion
//#region src/types/db.d.ts
type CapabilitiesBase = Record<string, Record<string, boolean>>;
type NamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
type NamespaceDomain = Readonly<Record<string, {
  readonly models: Readonly<Record<string, unknown>>;
}>>;
type TableProxyContract = {
  readonly domain: {
    readonly namespaces: NamespaceDomain;
  };
  readonly storage: {
    readonly namespaces: Readonly<Record<string, {
      readonly entries: NamespaceEntries;
    }>>;
  };
  readonly capabilities: CapabilitiesBase;
};
type TablesInNamespace<NS extends {
  readonly entries: NamespaceEntries;
}> = NS['entries']['table'] extends Readonly<Record<string, StorageTable>> ? NS['entries']['table'] : Readonly<Record<string, StorageTable>>;
type UnboundTables<C extends TableProxyContract> = { readonly [Name in TableNamesAcrossNamespaces<C>]: TableInAnyNamespace<C, Name>; };
type TableNamesAcrossNamespaces<C extends TableProxyContract> = { [NSId in keyof C['storage']['namespaces']]: keyof TablesInNamespace<C['storage']['namespaces'][NSId]> & string; }[keyof C['storage']['namespaces']];
type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = { [NSId in keyof C['storage']['namespaces']]: Name extends keyof TablesInNamespace<C['storage']['namespaces'][NSId]> ? TablesInNamespace<C['storage']['namespaces'][NSId]>[Name] : never; }[keyof C['storage']['namespaces']];
type NamespaceTable<C extends TableProxyContract, NsId extends string, Name extends string> = TablesInNamespace<C['storage']['namespaces'][NsId]>[Name];
type Namespace<C extends TableProxyContract, NsId extends string & keyof C['storage']['namespaces']> = { readonly [Name in keyof TablesInNamespace<C['storage']['namespaces'][NsId]> & string]: TableProxy<C, NsId, Name>; };
type Db<C extends TableProxyContract> = { readonly [Ns in keyof C['storage']['namespaces'] & string]: Namespace<C, Ns>; };
//#endregion
export { Subquery as C, ScopeField as S, FieldProxy as _, TableProxyContract as a, QueryContext as b, SelectQuery as c, InsertQuery as d, UpdateQuery as f, Expression$1 as g, BooleanCodecType as h, TableNamesAcrossNamespaces as i, GroupedQuery as l, AggregateFunctions as m, Namespace as n, UnboundTables as o, ResolveRow as p, TableInAnyNamespace as r, TableProxy as s, Db as t, DeleteQuery as u, Functions as v, Scope as x, GatedMethod as y };
//# sourceMappingURL=db-D1Zq4FVc.d.mts.map