typion 0.0.0-stage → 0.1.0

package/dist/context-CpLQy7OI.d.ts

@@ -0,0 +1,2098 @@
+import { AnyPgColumn, AnyPgColumnBuilder, ExtraConfigColumn, IndexBuilder, PgAsyncDatabase, PgAsyncTransaction, PgBuildColumns, PgColumn, PgEnum, PgIntegerBuilder, PgJsonbBuilder, PgQueryResultHKT, PgSchema, PgTable, PgTableExtraConfigValue, PgTableWithColumns, PgTextBuilder, PgTransactionConfig, PgUUIDBuilder, SetNotNull } from "drizzle-orm/pg-core";
+import { $Type, AnyRelations, AnyRelationsBuilderConfig, Assume, BuildQueryResult, DBQueryConfig, DBQueryConfigOrderByObject, ExtractTablesFromSchema, ExtractTablesWithRelations, GetTableViewFieldSelection, KnownKeysOnly, Many, One, RelationsBuilder, RelationsBuilderConfig, RelationsFilter, RelationsRecord, SQL } from "drizzle-orm";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/contract/descriptor.d.ts
+declare const RESULT: unique symbol;
+type ReadOp = 'find' | 'findOne' | 'findById' | 'count' | 'page';
+type WriteOp = 'create' | 'update' | 'updateMany' | 'delete' | 'deleteMany';
+type Op = ReadOp | WriteOp | (string & {});
+interface Descriptor<TEntity extends string, TOp extends Op, TInput, TResult> {
+  readonly entity: TEntity;
+  readonly op: TOp;
+  readonly input: TInput;
+  readonly [RESULT]?: TResult;
+}
+type AnyDescriptor = Descriptor<string, Op, unknown, unknown>;
+type InferResult<Q> = Q extends {
+  readonly [RESULT]?: infer T;
+} ? T : never;
+type InferItem<Q> = InferResult<Q> extends readonly (infer El)[] ? El : InferResult<Q> extends {
+  items: readonly (infer El)[];
+} ? El : NonNullable<InferResult<Q>>;
+declare function descriptor<E extends string, O extends Op, I>(entity: E, op: O, input: I): Descriptor<E, O, I, unknown>;
+//#endregion
+//#region src/errors.d.ts
+type TypionErrorCode = 'NOT_FOUND' | 'FORBIDDEN' | 'VALIDATION' | 'CONFLICT' | 'INVALID_STATE' | 'BAD_REQUEST' | 'UNSUPPORTED' | 'PLUGIN' | 'CONFIG' | 'INTERNAL';
+type TypionErrorOptions = {
+  entity?: string;
+  details?: Record<string, unknown>;
+  cause?: unknown;
+};
+declare abstract class TypionError extends Error {
+  abstract readonly code: TypionErrorCode;
+  abstract readonly status: number;
+  readonly entity: string | undefined;
+  readonly details: Record<string, unknown> | undefined;
+  constructor(message: string, opts?: TypionErrorOptions);
+}
+declare class NotFoundError extends TypionError {
+  readonly code: 'NOT_FOUND';
+  readonly status: 404;
+}
+type ForbiddenErrorOptions = TypionErrorOptions & {
+  operation?: string;
+  rule?: string;
+};
+declare class ForbiddenError extends TypionError {
+  readonly code: 'FORBIDDEN';
+  readonly status: 403;
+  readonly operation: string | undefined;
+  readonly rule: string | undefined;
+  constructor(message: string, opts?: ForbiddenErrorOptions);
+}
+type ValidationIssue = {
+  readonly path: readonly PropertyKey[];
+  readonly message: string;
+};
+declare class ValidationError extends TypionError {
+  readonly code: 'VALIDATION';
+  readonly status: 422;
+  readonly issues: readonly ValidationIssue[];
+  constructor(message: string, issues: readonly ValidationIssue[], opts?: TypionErrorOptions);
+}
+type ConflictKind = 'unique' | 'foreign_key' | 'check' | 'serialization' | 'deadlock';
+type ConflictErrorOptions = TypionErrorOptions & {
+  constraint?: string;
+  retryable?: boolean;
+  issues?: readonly ValidationIssue[];
+};
+declare class ConflictError extends TypionError {
+  readonly code: 'CONFLICT';
+  readonly status: 409;
+  readonly kind: ConflictKind;
+  readonly constraint: string | undefined;
+  readonly retryable: boolean;
+  readonly issues?: readonly ValidationIssue[];
+  constructor(message: string, kind: ConflictKind, opts?: ConflictErrorOptions);
+}
+declare class InvalidStateError extends TypionError {
+  readonly code: 'INVALID_STATE';
+  readonly status: 409;
+}
+declare class BadRequestError extends TypionError {
+  readonly code: 'BAD_REQUEST';
+  readonly status: 400;
+}
+declare class UnsupportedError extends TypionError {
+  readonly code: 'UNSUPPORTED';
+  readonly status: 400;
+}
+type PluginErrorOptions = TypionErrorOptions & {
+  status?: number;
+};
+declare class PluginError extends TypionError {
+  readonly code: 'PLUGIN';
+  readonly status: number;
+  readonly pluginId: string;
+  readonly pluginCode: string;
+  constructor(message: string, pluginId: string, pluginCode: string, opts?: PluginErrorOptions);
+}
+type ConfigErrorKind = 'config' | 'schema_drift' | 'relations_mismatch';
+declare class ConfigError extends TypionError {
+  readonly code: 'CONFIG';
+  readonly status: 500;
+  readonly kind: ConfigErrorKind;
+  constructor(message: string, kind?: ConfigErrorKind, opts?: TypionErrorOptions);
+}
+declare class InternalError extends TypionError {
+  readonly code: 'INTERNAL';
+  readonly status: 500;
+}
+declare function isTypionError(e: unknown, code?: TypionErrorCode): e is TypionError;
+type Attempt<T> = {
+  ok: true;
+  data: T;
+} | {
+  ok: false;
+  error: TypionError;
+};
+declare function attempt<T>(fn: () => Promise<T>): Promise<Attempt<T>>;
+//#endregion
+//#region src/types/kinds.d.ts
+declare const COLUMN_KIND: unique symbol;
+type ColumnKindTypes = {
+  readonly plugin: string;
+  readonly read: object;
+  readonly write?: object;
+};
+type Kinded<K extends ColumnKindTypes> = {
+  readonly [COLUMN_KIND]?: K;
+};
+type KindOf<D> = D extends {
+  readonly [COLUMN_KIND]?: infer K;
+} ? K extends ColumnKindTypes ? K : never : never;
+interface ReadModeFn {
+  readonly config: unknown;
+  readonly mode: string;
+}
+interface WriteModeFn {
+  readonly config: unknown;
+  readonly mode: string;
+}
+type KindTypesOf<H> = H extends {
+  readonly columnKinds?: infer S;
+} ? NonNullable<S> extends {
+  readonly $types?: infer T;
+} ? NonNullable<T> : never : never;
+type IdOf$1<H> = H extends {
+  readonly id: infer Id extends string;
+} ? Id : never;
+type ReadModeFnOf<H> = [KindTypesOf<H>] extends [never] ? never : KindTypesOf<H> extends {
+  readonly readMode: infer F extends ReadModeFn;
+} ? F : never;
+type WriteModeFnOf<H> = [KindTypesOf<H>] extends [never] ? never : KindTypesOf<H> extends {
+  readonly writeMode: infer F extends WriteModeFn;
+} ? F : never;
+type FilterModeOf<H> = [KindTypesOf<H>] extends [never] ? never : KindTypesOf<H> extends {
+  readonly filterMode: infer M extends string;
+} ? M : never;
+type ReadModeOf<C, P extends readonly unknown[], Acc extends string = ''> = P extends readonly [infer H, ...infer R] ? [ReadModeFnOf<H>] extends [never] ? ReadModeOf<C, R, Acc> : ReadModeOf<C, R, `${Acc}|${IdOf$1<H>}=${(ReadModeFnOf<H> & {
+  readonly config: C;
+})['mode']}|`> : Acc;
+type WriteModeOf<O, P extends readonly unknown[], Acc extends string = ''> = P extends readonly [infer H, ...infer R] ? [WriteModeFnOf<H>] extends [never] ? WriteModeOf<O, R, Acc> : WriteModeOf<O, R, `${Acc}|${IdOf$1<H>}=${(WriteModeFnOf<H> & {
+  readonly config: O;
+})['mode']}|`> : Acc;
+type InputModeOf<P extends readonly unknown[], Acc extends string = ''> = P extends readonly [infer H, ...infer R] ? [FilterModeOf<H>] extends [never] ? InputModeOf<R, Acc> : InputModeOf<R, `${Acc}|${IdOf$1<H>}=${FilterModeOf<H>}|`> : Acc;
+type SegmentOf<M extends string, G extends string> = M extends `${string}|${G}=${infer S}|${string}` ? S : never;
+type KindRead<K extends ColumnKindTypes, M extends string, Storage> = [SegmentOf<M, K['plugin']>] extends [never] ? Storage : K['read'][SegmentOf<M, K['plugin']> & keyof K['read']];
+type KindedData<D, M extends string> = [KindOf<D>] extends [never] ? D : KindRead<KindOf<D>, M, D>;
+type PluginsOfColumns<T extends PgTable> = { [K in keyof T['_']['columns']]: KindOf<Assume<T['_']['columns'][K], AnyPgColumn>['_']['data']>['plugin']; }[keyof T['_']['columns']];
+type PickSegments<M extends string, G extends string, Acc extends string = ''> = M extends `|${infer Id}=${infer S}|${infer Rest}` ? PickSegments<Rest, G, Id extends G ? `${Acc}|${Id}=${S}|` : Acc> : Acc;
+type TableMode<T extends PgTable, M extends string> = [PluginsOfColumns<T>] extends [never] ? '' : PickSegments<M, PluginsOfColumns<T>>;
+type KindWrite<D, M extends string> = [KindOf<NonNullable<D>>] extends [never] ? D : KindOf<NonNullable<D>> extends {
+  readonly write: infer W;
+  readonly plugin: infer G extends string;
+} ? [SegmentOf<M, G>] extends [never] ? D : W[SegmentOf<M, G> & keyof W] | Extract<D, null | undefined> : D;
+type UnionToIntersection$1<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type Flatten$2<T> = { [K in keyof T]: T[K]; } & {};
+type CarrierOf<H, K extends string> = [KindTypesOf<H>] extends [never] ? {} : KindTypesOf<H> extends { readonly [P in K]: infer O extends object; } ? O : {};
+type PluginReadOptions<P extends readonly unknown[]> = [P[number]] extends [never] ? {} : Flatten$2<UnionToIntersection$1<CarrierOf<P[number], 'readOptions'>>>;
+type KindWriteOptions<P extends readonly unknown[], T extends PgTable> = [PluginsOfColumns<T>] extends [never] ? {} : Flatten$2<UnionToIntersection$1<CarrierOf<Extract<P[number], {
+  readonly id: PluginsOfColumns<T>;
+}>, 'writeOptions'>>>;
+type ContextOptionsOf<H> = H extends {
+  readonly contextOptions?: infer C;
+} ? NonNullable<C> extends {
+  $type: infer T extends object;
+} ? T : {} : {};
+type PluginContextOptions<P extends readonly unknown[]> = [P[number]] extends [never] ? {} : Flatten$2<UnionToIntersection$1<ContextOptionsOf<P[number]>>>;
+type SystemOptionsOf<H> = H extends {
+  readonly systemOptions?: infer C;
+} ? NonNullable<C> extends {
+  $type: infer T extends object;
+} ? T : {} : {};
+type PluginSystemOptions<P extends readonly unknown[]> = [P[number]] extends [never] ? {} : Flatten$2<UnionToIntersection$1<SystemOptionsOf<P[number]>>>;
+type KeyedShape = {
+  readonly type: 'keyed';
+  readonly keyName: string;
+  readonly keys: readonly string[];
+  readonly required: readonly string[];
+  readonly nonNull: readonly string[];
+  readonly value?: AnyPgColumn;
+};
+type ValidationMode = 'insert' | 'update' | 'select';
+type ColumnKindSpec<TState = any, TWriteState = any> = {
+  readonly project?: (values: unknown[], state: TState) => unknown[] | Promise<unknown[]>;
+  readonly expression?: (input: {
+    readonly column: AnyPgColumn | SQL;
+    readonly state: TState;
+    readonly sample: unknown;
+    readonly dialect: Dialect;
+  }) => SQL;
+  readonly write?: (input: {
+    readonly value: unknown;
+    readonly stored: unknown;
+    readonly state: TWriteState;
+  }) => unknown;
+  readonly validation?: (column: ColumnMeta, mode: ValidationMode) => KeyedShape;
+  readonly diff?: (before: unknown, after: unknown) => {
+    before: unknown;
+    after: unknown;
+  };
+};
+type OptionType = 'string' | 'boolean' | 'number';
+type ColumnKindsTypes = {
+  readonly readMode?: ReadModeFn;
+  readonly filterMode?: string;
+  readonly writeMode?: WriteModeFn;
+  readonly readOptions?: object;
+  readonly writeOptions?: object;
+};
+type ColumnKindsSpec<TTypes extends ColumnKindsTypes = ColumnKindsTypes> = {
+  readonly $types?: TTypes;
+  readonly readOptions?: Readonly<Record<string, OptionType>>;
+  readonly writeOptions?: Readonly<Record<string, OptionType>>;
+  readonly read?: (input: {
+    readonly options: Readonly<Record<string, unknown>>;
+    readonly ctx: BaseContext & Readonly<Record<string, unknown>>;
+  }) => unknown;
+  readonly write?: (input: {
+    readonly options: Readonly<Record<string, unknown>>;
+    readonly ctx: BaseContext & Readonly<Record<string, unknown>>;
+  }) => unknown;
+  readonly kinds: Readonly<Record<string, ColumnKindSpec>>;
+};
+type ColumnKindRuntime = ColumnKindSpec & {
+  readonly id: string;
+  readonly plugin: string;
+};
+//#endregion
+//#region src/types/plugin.d.ts
+type TableShape<TColumns extends Record<string, AnyPgColumn>> = PgTableWithColumns<{
+  name: string;
+  schema: string | undefined;
+  dialect: 'pg';
+  columns: TColumns;
+}>;
+type PluginErrorDef = {
+  status: number;
+  message: string;
+};
+type PluginRoute = {
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+  path: string;
+  handler: (c: {
+    request: Request;
+    params: Record<string, string>;
+    engine: AnyTypion;
+    app: AnyTypionApp;
+  }) => MaybePromise<Response>;
+};
+interface ColumnKind<TId extends string, TMeta> {
+  readonly id: TId;
+  mark<B extends AnyPgColumnBuilder>(builder: B, meta?: TMeta): B;
+  markColumns<T extends PgTable>(table: T, columns: readonly (keyof T['_']['columns'])[]): void;
+  is(column: AnyPgColumn): boolean;
+  metaOf(column: AnyPgColumn): TMeta | undefined;
+}
+type PluginEntityDefiner<TTables extends Record<string, PgTable>> = <N extends keyof TTables & string, const O>(name: N, options: O) => EntityDef<N, O>;
+interface CollectionKinds {
+  readonly options: unknown;
+  readonly columns: {};
+  readonly entity: {};
+}
+type SeedGenerators = {
+  default(params: {
+    defaultValue: unknown;
+    arraySize?: number;
+  }): unknown;
+  valuesFromArray(params: {
+    values: readonly unknown[];
+    isUnique?: boolean;
+  }): unknown;
+} & Record<string, (params?: any) => unknown>;
+type SeedColumnsInput = {
+  readonly generators: SeedGenerators;
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly count: number;
+};
+type SeedSpec = {
+  columns?: (entity: EntityMeta, input: SeedColumnsInput) => Record<string, unknown>;
+};
+type CollectionSpec<TKinds extends CollectionKinds = CollectionKinds, TOptions extends object = {}> = {
+  $options?: TOptions;
+  $kinds?: TKinds;
+  consumes?: readonly string[];
+  columns?: (options: Readonly<Record<string, unknown>>) => Record<string, AnyPgColumnBuilder>;
+  entity?: (options: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+};
+interface PluginSpec<TId extends string = string, TTables extends Record<string, PgTable> = {}, TRequires extends Record<string, PgTable> = {}, TCtx extends object = {}, TApi = {}, TEntityOptions extends object = {}, TErrors extends Record<string, PluginErrorDef> = {}, TKinds extends CollectionKinds = CollectionKinds, TCollectionOptions extends object = {}, TSystemOptions extends object = {}, TNeedsCtx extends object = {}, TColumnKinds extends ColumnKindsTypes = ColumnKindsTypes, TContextOptions extends object = {}, TTraits extends EntityTraits = never, TDependsOn extends string = never, TFeatureTables extends AnyFeatureTables = {}> {
+  id: TId;
+  dependsOn?: readonly TDependsOn[];
+  tables?: TTables;
+  featureTables?: TFeatureTables;
+  requires?: TRequires;
+  needsContext?: {
+    $type: TNeedsCtx;
+  };
+  relations?: (r: RelationsBuilder<TTables & TRequires>) => RelationsBuilderConfig<TTables & TRequires>;
+  entities?: (define: PluginEntityDefiner<TTables>) => Record<string, EntityDef<string, unknown>>;
+  entityOptions?: {
+    $type: TEntityOptions;
+    schema?: StandardSchemaV1;
+  };
+  collection?: CollectionSpec<TKinds, TCollectionOptions>;
+  seed?: SeedSpec;
+  columnKinds?: ColumnKindsSpec<TColumnKinds>;
+  contextOptions?: {
+    $type: TContextOptions;
+  };
+  systemOptions?: {
+    $type: TSystemOptions;
+  };
+  requestHeaders?: readonly string[];
+  traits?: TraitsSpec<TTraits>;
+  init?: (engine: AnyTypion) => MaybePromise<void>;
+  context?: (base: BaseContext, input: ContextInput) => MaybePromise<TCtx>;
+  hooks?: GlobalHooks;
+  api?: (engine: AnyTypion, app?: AnyTypionApp) => TApi;
+  routes?: readonly PluginRoute[];
+  errors?: TErrors;
+}
+type AnyPluginSpec = {
+  readonly id: string;
+  readonly dependsOn?: readonly string[] | undefined;
+  readonly tables?: Record<string, PgTable> | undefined;
+  readonly featureTables?: { readonly [F in FeatureId]?: {
+    readonly [key: string]: PgTable | undefined;
+  }; } | undefined;
+  readonly requires?: Record<string, PgTable> | undefined;
+  readonly relations?: ((r: never) => AnyRelationsBuilderConfig) | undefined;
+  readonly entities?: ((define: never) => Record<string, EntityDef<string, unknown>>) | undefined;
+  readonly entityOptions?: {
+    $type: object;
+    schema?: StandardSchemaV1;
+  } | undefined;
+  readonly needsContext?: {
+    $type: object;
+  } | undefined;
+  readonly collection?: CollectionSpec | undefined;
+  readonly seed?: SeedSpec | undefined;
+  readonly columnKinds?: ColumnKindsSpec | undefined;
+  readonly contextOptions?: {
+    $type: object;
+  } | undefined;
+  readonly systemOptions?: {
+    $type: object;
+  } | undefined;
+  readonly requestHeaders?: readonly string[] | undefined;
+  readonly traits?: TraitsSpec | undefined;
+  readonly init?: ((engine: AnyTypion) => MaybePromise<void>) | undefined;
+  readonly context?: ((base: BaseContext, input: ContextInput) => MaybePromise<object>) | undefined;
+  readonly hooks?: GlobalHooks | undefined;
+  readonly api?: ((engine: AnyTypion, app?: AnyTypionApp) => unknown) | undefined;
+  readonly routes?: readonly PluginRoute[] | undefined;
+  readonly errors?: Record<string, PluginErrorDef> | undefined;
+};
+type CallbackReturn<P, K extends PropertyKey> = P extends { [Key in K]?: infer F; } ? NonNullable<F> extends ((...a: never[]) => infer R) ? R : {} : {};
+type Plugin<P extends AnyPluginSpec> = P & {
+  readonly $api: CallbackReturn<P, 'api'>;
+  readonly $context: Awaited<CallbackReturn<P, 'context'>>;
+  readonly $entityOptions: P extends {
+    entityOptions?: infer EO;
+  } ? NonNullable<EO> extends {
+    $type: infer T;
+  } ? T : {} : {};
+  readonly $entities: CallbackReturn<P, 'entities'> extends (infer E) ? E extends AnyEntities ? E : {} : {};
+};
+type AnyPlugin = Plugin<AnyPluginSpec>;
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type FeatureId = 'localization' | 'multiTenant';
+type FeatureTables<TTables> = { readonly [F in FeatureId]?: { readonly [K in keyof TTables]?: PgTable; }; };
+type AnyFeatureTables = { readonly [F in FeatureId]?: {
+  readonly [key: string]: PgTable | undefined;
+}; };
+type VariantOf<Q, F> = Q extends {
+  readonly featureTables?: infer V;
+} ? UnionToIntersection<{ [K in keyof NonNullable<V> & F]: NonNullable<NonNullable<V>[K]>; }[keyof NonNullable<V> & F]> extends (infer T) ? [T] extends [never] ? {} : T : {} : {};
+type TablesOf$1<Q, F> = Q extends {
+  readonly tables?: infer T;
+} ? VariantOf<Q, F> extends (infer V) ? Omit<NonNullable<T>, keyof V> & V : never : {};
+type PluginTables<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<TablesOf$1<P[number], P[number]['id']>>;
+type PluginEntities<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<P[number]['$entities']>;
+type PluginContext<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<P[number]['$context']>;
+type PluginEntityOptions<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<P[number]['$entityOptions']>;
+type NeedsCtxOf<P> = P extends {
+  needsContext?: infer NC;
+} ? NonNullable<NC> extends {
+  $type: infer T;
+} ? T : {} : {};
+type PluginNeedsContext<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<NeedsCtxOf<P[number]>>;
+type CollectionOptionsOf<P> = P extends {
+  collection?: infer C;
+} ? NonNullable<C> extends {
+  $options?: infer O;
+} ? NonNullable<O> : {} : {};
+type PluginCollectionOptions<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : UnionToIntersection<CollectionOptionsOf<P[number]>>;
+type PluginKinds<P> = P extends {
+  collection?: infer C;
+} ? NonNullable<C> extends {
+  $kinds?: infer K;
+} ? NonNullable<K> extends CollectionKinds ? NonNullable<K> : CollectionKinds : CollectionKinds : CollectionKinds;
+type PluginErrorInput = {
+  message?: string;
+  details?: Record<string, unknown>;
+  cause?: unknown;
+};
+type PluginErrorFactories<P> = P extends {
+  errors?: infer E;
+} ? { [K in keyof NonNullable<E>]: (input?: PluginErrorInput) => PluginError; } : {};
+type PluginApis<P extends readonly AnyPlugin[]> = [P[number]] extends [never] ? {} : { [K in P[number]['id']]: Extract<P[number], {
+  id: K;
+}>['$api'] & {
+  errors: PluginErrorFactories<Extract<P[number], {
+    id: K;
+  }>>;
+}; };
+type RelsAt<T, K> = K extends keyof T ? (T[K] extends RelationsRecord ? T[K] : {}) : {};
+type MergeConfigs<A, B> = { [K in keyof A | keyof B]: RelsAt<A, K> & RelsAt<B, K>; };
+type PluginConfig<P> = P extends {
+  relations?: (r: never) => infer C;
+} ? C extends AnyRelationsBuilderConfig ? C : {} : {};
+type MergeAll<T extends readonly unknown[], Acc = {}> = T extends readonly [infer H, ...infer R] ? MergeAll<R, MergeConfigs<Acc, PluginConfig<H>>> : Acc;
+type RequirementsError<TUser, TPlugins extends readonly unknown[]> = TUser extends UnionToIntersection<NonNullable<Extract<TPlugins[number], {
+  requires?: unknown;
+}>['requires']>> ? unknown : {
+  plugins: 'Plugin requirements not met by `tables`';
+};
+type IdOf<H> = H extends {
+  readonly id: infer I extends string;
+} ? I : never;
+type DependsOnOf<H> = H extends {
+  readonly dependsOn?: readonly (infer D extends string)[] | undefined;
+} ? D : never;
+type DependencyMessage<TId extends string, TMissing extends string, TInstalled> = [TMissing & TInstalled] extends [never] ? `plugin '${TId}' needs plugin '${TMissing}', which is not installed` : `plugin '${TId}' needs plugin '${TMissing & TInstalled & string}' installed before it`;
+type DependenciesError<P extends readonly unknown[], TInstalled = IdOf<P[number]>, TBefore = never> = P extends readonly [infer H, ...infer R] ? [Exclude<DependsOnOf<H>, TBefore>] extends [never] ? DependenciesError<R, TInstalled, TBefore | IdOf<H>> : {
+  '~error': DependencyMessage<IdOf<H>, Exclude<DependsOnOf<H>, TBefore>, TInstalled>;
+} : unknown;
+interface PluginRuntime {
+  readonly id: string;
+  readonly spec: AnyPluginSpec;
+  readonly columnKinds: ColumnKindsSpec | null;
+  readonly traits: TraitsSpec | null;
+  readonly tables: Readonly<Record<string, PgTable>>;
+  readonly entities: Readonly<Record<string, EntityDef<string, unknown>>>;
+  readonly hooks: GlobalHooks | null;
+  readonly routes: readonly PluginRoute[];
+  readonly errors: Readonly<Record<string, PluginErrorDef>>;
+}
+//#endregion
+//#region src/types/schema.d.ts
+type RemapData<C extends AnyPgColumn, D> = PgColumn<C['_']['dataType'], Omit<C['_'], 'data'> & {
+  data: D;
+}>;
+type VirtualColumn<C extends AnyPgColumn, M extends string, Dyn extends boolean> = Dyn extends true ? RemapData<C, KindedData<C['_']['data'], M> | null> : [KindOf<C['_']['data']>] extends [never] ? C : RemapData<C, KindedData<C['_']['data'], M>>;
+type VirtualTable<T extends PgTable, M extends string, Hidden extends PropertyKey, Dyn extends PropertyKey> = PgTableWithColumns<{
+  name: T['_']['name'];
+  schema: T['_']['schema'];
+  dialect: 'pg';
+  columns: { [K in keyof T['_']['columns'] as K extends Hidden ? never : K]: VirtualColumn<Assume<T['_']['columns'][K], AnyPgColumn>, M, K extends Dyn ? true : false>; };
+}>;
+type ReadRuleOf<O> = O extends {
+  access: {
+    read: infer Rd;
+  };
+} ? Rd : undefined;
+type AclGoverned<O> = ReadRuleOf<O> extends true ? false : ReadRuleOf<O> extends undefined ? false : true;
+type Governed<E extends AnyEntities, P extends readonly unknown[], N, TMode extends TypionMode> = N extends keyof E ? TraitGoverned<P, E[N]['options']> extends true ? true : TMode extends 'system' ? false : AclGoverned<E[N]['options']> : false;
+type HiddenReadKeys<E extends AnyEntities, N> = N extends keyof E ? E[N]['options'] extends {
+  fields: infer F;
+} ? { [K in keyof F]: F[K] extends {
+  read: false;
+} ? K : never; }[keyof F] : never : never;
+type DynamicReadKeys<E extends AnyEntities, N> = N extends keyof E ? E[N]['options'] extends {
+  fields: infer F;
+} ? { [K in keyof F]: F[K] extends {
+  read: (...a: never[]) => unknown;
+} ? K : never; }[keyof F] : never : never;
+type VirtualRelation<Rel, E extends AnyEntities, P extends readonly unknown[], TMode extends TypionMode> = Rel extends One<infer T, boolean> ? Governed<E, P, T, TMode> extends true ? One<T, true> : Rel : Rel;
+type VS<TE extends TypionTypes, M extends string, TMode extends TypionMode> = { [K in keyof TE['relations']]: {
+  table: VirtualTable<Assume<TE['relations'][K]['table'], PgTable>, TableMode<Assume<TE['relations'][K]['table'], PgTable>, M>, HiddenReadKeys<TE['entities'], K>, DynamicReadKeys<TE['entities'], K>>;
+  name: TE['relations'][K]['name'];
+  relations: { [F in keyof TE['relations'][K]['relations']]: VirtualRelation<TE['relations'][K]['relations'][F], TE['entities'], TE['plugins'], TMode>; };
+}; };
+//#endregion
+//#region src/types/query.d.ts
+type ReadOptions<TE extends TypionTypes, N extends EntityName<TE>> = PluginReadOptions<TE['plugins']> & TraitOptions<TE['plugins'], TE['entities'][N]['options'], 'read'>;
+type InputSchema<TE extends TypionTypes, TMode extends TypionMode> = VS<TE, InputModeOf<TE['plugins']>, TMode>;
+type FindConfig<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> = DBQueryConfig<'many', InputSchema<TE, TMode>, InputSchema<TE, TMode>[N]> & ReadOptions<TE, N>;
+type FirstConfig<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> = DBQueryConfig<'one', InputSchema<TE, TMode>, InputSchema<TE, TMode>[N]> & ReadOptions<TE, N>;
+type ByIdConfig<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> = Omit<FirstConfig<TE, N, TMode>, 'where' | 'offset'>;
+type Where<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode = 'user'> = NonNullable<DBQueryConfig<'many', InputSchema<TE, TMode>, InputSchema<TE, TMode>[N]>['where']>;
+type OrderBy<TE extends TypionTypes, N extends EntityName<TE>> = DBQueryConfigOrderByObject<GetTableViewFieldSelection<InputSchema<TE, 'user'>[N]['table']>>;
+type CountConfig<TE extends TypionTypes, N extends EntityName<TE>> = {
+  where?: Where<TE, N>;
+} & ReadOptions<TE, N>;
+type Page<T> = {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+};
+type Extend<TE extends TypionTypes, N extends EntityName<TE>> = {
+  where?: Where<TE, N>;
+  orderBy?: OrderBy<TE, N>;
+  limit?: number;
+  offset?: number;
+};
+type Result<TE extends TypionTypes, N extends EntityName<TE>, C extends Record<string, unknown>, TMode extends TypionMode> = ReadModeOf<C, TE['plugins']> extends (infer M) ? M extends string ? BuildQueryResult<VS<TE, M, TMode>, VS<TE, M, TMode>[N], C> : never : never;
+//#endregion
+//#region src/types/entity.d.ts
+interface EntityDef<N extends string, O> {
+  readonly name: N;
+  readonly options: O;
+}
+type AnyEntities = Record<string, EntityDef<string, unknown>>;
+type EntitiesOf$1<R extends AnyRelations> = { [N in keyof R & string]?: EntityDef<N, unknown>; };
+type Select<TE extends TypionTypes, N extends EntityName<TE>> = Assume<TE['relations'][N]['table'], {
+  $inferSelect: Record<string, unknown>;
+}>['$inferSelect'];
+type Insert<TE extends TypionTypes, N extends EntityName<TE>> = Assume<TE['relations'][N]['table'], {
+  $inferInsert: Record<string, unknown>;
+}>['$inferInsert'];
+type IdKey<TE extends TypionTypes, N extends EntityName<TE>> = TE['entities'][N]['options'] extends {
+  idColumn: infer K extends string;
+} ? K : 'id';
+type Id$1<TE extends TypionTypes, N extends EntityName<TE>> = Select<TE, N>[IdKey<TE, N> & keyof Select<TE, N>];
+type FieldsOf<TE extends TypionTypes, N extends keyof TE['entities']> = TE['entities'][N]['options'] extends {
+  fields: infer F;
+} ? F : {};
+type HiddenWriteKeys<TE extends TypionTypes, N extends keyof TE['entities'], TMode extends TypionMode = 'user'> = { [K in keyof FieldsOf<TE, N>]: FieldsOf<TE, N>[K] extends {
+  write: false;
+} ? K : FieldsOf<TE, N>[K] extends {
+  write: 'system';
+} ? TMode extends 'user' ? K : never : never; }[keyof FieldsOf<TE, N>];
+type ManagedKeys<TE extends TypionTypes, N extends keyof TE['entities']> = TraitManaged<TE['plugins'], TE['entities'][N]['options']>;
+type Flatten$1<T> = { [K in keyof T]: T[K]; } & {};
+type TableOfEntity<TE extends TypionTypes, N extends EntityName<TE>> = Assume<TE['relations'][N]['table'], PgTable>;
+type ReadRow<TE extends TypionTypes, N extends EntityName<TE>, C, TMode extends TypionMode = 'user'> = ReadModeOf<C, TE['plugins']> extends (infer M) ? M extends string ? BuildQueryResult<VS<TE, M, TMode>, VS<TE, M, TMode>[N], true> : never : never;
+type Row<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode = 'user'> = ReadRow<TE, N, {}, TMode>;
+type KindShape<T, M extends string> = M extends '' ? T : { [K in keyof T]: KindWrite<T[K], M>; };
+type WriteModeFor<TE extends TypionTypes, N extends EntityName<TE>, O> = TableMode<TableOfEntity<TE, N>, WriteModeOf<O, TE['plugins']>>;
+type WriteShape<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> = TMode extends 'user' ? Omit<Insert<TE, N>, HiddenWriteKeys<TE, N, 'user'> | ManagedKeys<TE, N>> : Omit<Insert<TE, N>, HiddenWriteKeys<TE, N, 'system'> | ManagedKeys<TE, N>> & Partial<Pick<Insert<TE, N>, ManagedKeys<TE, N> & keyof Insert<TE, N>>>;
+type CreateInput<TE extends TypionTypes, N extends EntityName<TE>, O, TMode extends TypionMode = 'user'> = Flatten$1<KindShape<WriteShape<TE, N, TMode>, WriteModeFor<TE, N, O>>>;
+type UpdateInput<TE extends TypionTypes, N extends EntityName<TE>, O, TMode extends TypionMode = 'user'> = Flatten$1<Partial<CreateInput<TE, N, O, TMode>>>;
+type NoExtraKeys<O, TAllowed> = { [K in Exclude<keyof O, keyof TAllowed>]: never; };
+type WriteOptions<TE extends TypionTypes, N extends EntityName<TE>> = KindWriteOptions<TE['plugins'], TableOfEntity<TE, N>>;
+type DeletableTarget<TE extends TypionTypes, N extends EntityName<TE>> = { [K in keyof TE['relations'][N]['relations']]: TE['relations'][N]['relations'][K] extends {
+  readonly relationType: 'one';
+  readonly targetTableName: infer T extends EntityName<TE>;
+} ? TE['entities'][T]['options'] extends {
+  softDelete: true;
+} ? true : never : never; }[keyof TE['relations'][N]['relations']];
+type ReferenceOptions<TE extends TypionTypes, N extends EntityName<TE>> = [DeletableTarget<TE, N>] extends [never] ? {} : {
+  withDeleted?: boolean;
+};
+type CreateOptions<TE extends TypionTypes, N extends EntityName<TE>> = TraitOptions<TE['plugins'], TE['entities'][N]['options'], 'create'> & WriteOptions<TE, N> & ReferenceOptions<TE, N>;
+type UpdateOptions<TE extends TypionTypes, N extends EntityName<TE>> = TraitOptions<TE['plugins'], TE['entities'][N]['options'], 'update'> & WriteOptions<TE, N> & ReferenceOptions<TE, N>;
+type UpdateManyOptions<TE extends TypionTypes, N extends EntityName<TE>> = {
+  max?: number;
+} & WriteOptions<TE, N> & ReferenceOptions<TE, N>;
+type DeleteOptions<TE extends TypionTypes, N extends EntityName<TE>> = TraitOptions<TE['plugins'], TE['entities'][N]['options'], 'delete'>;
+type NoneIfEmpty<T> = [keyof T] extends [never] ? Record<string, never> : T;
+type EntitySchemas<TE extends TypionTypes, N extends EntityName<TE>> = {
+  readonly insert: StandardSchemaV1<unknown, CreateInput<TE, N, {}>>;
+  readonly update: StandardSchemaV1<unknown, UpdateInput<TE, N, {}>>;
+  readonly select: StandardSchemaV1<unknown, Select<TE, N>>;
+};
+interface EntityApi<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> {
+  find<const C extends FindConfig<TE, N, TMode>>(config?: KnownKeysOnly<C, FindConfig<TE, N, TMode>>): Promise<Result<TE, N, C, TMode>[]>;
+  findOne<const C extends FirstConfig<TE, N, TMode>>(config?: KnownKeysOnly<C, FirstConfig<TE, N, TMode>>): Promise<Result<TE, N, C, TMode> | null>;
+  findById<const C extends ByIdConfig<TE, N, TMode>>(id: Id$1<TE, N>, config?: KnownKeysOnly<C, ByIdConfig<TE, N, TMode>>): Promise<Result<TE, N, C, TMode>>;
+  count(config?: CountConfig<TE, N>): Promise<number>;
+  page<const C extends FindConfig<TE, N, TMode>>(config: KnownKeysOnly<C, FindConfig<TE, N, TMode>>): Promise<Page<Result<TE, N, C, TMode>>>;
+  query<const C extends FindConfig<TE, N, 'user'>>(config: KnownKeysOnly<C, FindConfig<TE, N, 'user'>>): Descriptor<N, 'find', C, Result<TE, N, C, 'user'>[]>;
+  queryOne<const C extends FirstConfig<TE, N, 'user'>>(config: KnownKeysOnly<C, FirstConfig<TE, N, 'user'>>): Descriptor<N, 'findOne', C, Result<TE, N, C, 'user'> | null>;
+  run<D extends Descriptor<N, Op, unknown, unknown>>(descriptor: D, extend?: Extend<TE, N>): Promise<InferResult<D>>;
+  create<const O extends CreateOptions<TE, N>>(data: CreateInput<TE, N, O, TMode>, options?: O & NoExtraKeys<O, CreateOptions<TE, N>>): Promise<ReadRow<TE, N, O, TMode>>;
+  update<const O extends UpdateOptions<TE, N>>(id: Id$1<TE, N>, data: UpdateInput<TE, N, O, TMode>, options?: O & NoExtraKeys<O, UpdateOptions<TE, N>>): Promise<ReadRow<TE, N, O, TMode>>;
+  updateMany<const O extends UpdateManyOptions<TE, N>>(where: Where<TE, N, TMode>, data: UpdateInput<TE, N, O, TMode>, options?: O & NoExtraKeys<O, UpdateManyOptions<TE, N>>): Promise<{
+    count: number;
+  }>;
+  delete(id: Id$1<TE, N>, options?: NoneIfEmpty<DeleteOptions<TE, N>>): Promise<Row<TE, N, TMode>>;
+  deleteMany(where: Where<TE, N, TMode>, options?: {
+    max?: number;
+  } & DeleteOptions<TE, N>): Promise<{
+    count: number;
+  }>;
+  readonly schemas: EntitySchemas<TE, N>;
+}
+type LinkedRelations<TE extends TypionTypes, N extends EntityName<TE>> = TE['entities'][N]['options'] extends {
+  links: readonly (infer L extends string)[];
+} ? L : never;
+type LinkTarget<TE extends TypionTypes, N extends EntityName<TE>, R> = TE['relations'][N]['relations'][R & keyof TE['relations'][N]['relations']] extends {
+  targetTableName: infer T extends EntityName<TE>;
+} ? T : never;
+type LinkApi<TE extends TypionTypes, N extends EntityName<TE>> = [LinkedRelations<TE, N>] extends [never] ? {} : LinkMethods<TE, N, LinkedRelations<TE, N>>;
+interface LinkMethods<TE extends TypionTypes, N extends EntityName<TE>, L extends string> {
+  link<const R extends L>(id: Id$1<TE, N>, relation: R, ids: Id$1<TE, LinkTarget<TE, N, R>> | readonly Id$1<TE, LinkTarget<TE, N, R>>[]): Promise<{
+    count: number;
+  }>;
+  unlink<const R extends L>(id: Id$1<TE, N>, relation: R, ids: Id$1<TE, LinkTarget<TE, N, R>> | readonly Id$1<TE, LinkTarget<TE, N, R>>[]): Promise<{
+    count: number;
+  }>;
+}
+type LinkInput<TE extends TypionTypes, N extends EntityName<TE>, R> = {
+  id: Id$1<TE, N>;
+  relation: R;
+  ids: readonly Id$1<TE, LinkTarget<TE, N, R>>[];
+};
+type LinkQueries<TE extends TypionTypes, N extends EntityName<TE>> = [LinkedRelations<TE, N>] extends [never] ? {} : LinkQueryMethods<TE, N, LinkedRelations<TE, N>>;
+interface LinkQueryMethods<TE extends TypionTypes, N extends EntityName<TE>, L extends string> {
+  link<const R extends L>(input: LinkInput<TE, N, R>): Descriptor<N, 'link', LinkInput<TE, N, R>, {
+    count: number;
+  }>;
+  unlink<const R extends L>(input: LinkInput<TE, N, R>): Descriptor<N, 'unlink', LinkInput<TE, N, R>, {
+    count: number;
+  }>;
+}
+type FieldRuleArgs<Ctx> = {
+  ctx: Ctx;
+  meta: OperationMeta;
+};
+type TableOf$1<R extends AnyRelations, N extends keyof R> = Assume<R[N]['table'], PgTable>;
+type ColumnKeys<R extends AnyRelations, N extends keyof R> = keyof TableOf$1<R, N>['_']['columns'] & string;
+type NullableTimestampKeys<T extends PgTable> = { [K in keyof T['_']['columns']]: Assume<T['_']['columns'][K], AnyPgColumn>['_'] extends {
+  dataType: 'object date';
+  notNull: false;
+} ? K : never; }[keyof T['_']['columns']];
+type FieldOptions<Ctx> = {
+  read?: false | ((a: FieldRuleArgs<Ctx>) => boolean);
+  write?: false | 'system' | ((a: FieldRuleArgs<Ctx>) => boolean);
+  kind?: string;
+};
+type FieldRefinements<R extends AnyRelations, N extends keyof R> = { [K in ColumnKeys<R, N>]?: unknown; };
+type EntityValidation<R extends AnyRelations, N extends keyof R> = {
+  insert?: StandardSchemaV1;
+  update?: StandardSchemaV1;
+  fields?: FieldRefinements<R, N>;
+};
+type EntityOptions<R extends AnyRelations, N extends keyof R & string, Ctx, P extends readonly AnyPlugin[]> = {
+  idColumn?: ColumnKeys<R, N>;
+  fields?: { [K in ColumnKeys<R, N>]?: FieldOptions<Ctx>; };
+  access?: AccessRules<R, N, Ctx, P>;
+  hooks?: EntityHooks<R, N, Ctx, P>;
+  validate?: EntityValidation<R, N>;
+  defaultOrder?: DBQueryConfigOrderByObject<GetTableViewFieldSelection<TableOf$1<R, N>>>;
+  maxLimit?: number;
+  links?: readonly (keyof R[N]['relations'] & string)[];
+} & PluginEntityOptions<P> & TraitEntityOptions<P, TableOf$1<R, N>>;
+//#endregion
+//#region src/types/traits.d.ts
+type OptionGroup = 'read' | 'create' | 'update' | 'delete';
+type RuleKind = 'filter' | 'boolean';
+type HookArgGroup = 'change' | 'afterChange' | 'afterDelete';
+interface EntityTraits {
+  readonly table: unknown;
+  readonly given: unknown;
+  readonly te: unknown;
+  readonly name: unknown;
+  readonly mode: unknown;
+  readonly row: unknown;
+  readonly entityOptions: object;
+  readonly governs: unknown;
+  readonly managed: string;
+  readonly optionsOn: OptionGroup;
+  readonly optionTypes: object;
+  readonly operations: string;
+  readonly rules: {
+    readonly [name: string]: RuleKind;
+  };
+  readonly rulesOn: string;
+  readonly hookArgs: { readonly [G in HookArgGroup]?: object; };
+  readonly api: object;
+  readonly queries: object;
+}
+type EntityTableOf<T extends EntityTraits> = T['table'] extends (infer X extends PgTable) ? X : never;
+type EntityIdOf<T extends EntityTraits> = T['te'] extends (infer TE extends TypionTypes) ? Id$1<TE, T['name'] & EntityName<TE>> : never;
+type EntitySelectOf<T extends EntityTraits> = T['te'] extends (infer TE extends TypionTypes) ? Select<TE, T['name'] & EntityName<TE>> : never;
+type EntityRowOf<T extends EntityTraits> = T['te'] extends (infer TE extends TypionTypes) ? Row<TE, T['name'] & EntityName<TE>, T['mode'] & TypionMode> : never;
+type Declared<T, Base> = Base extends T ? never : T;
+type TraitsOf<H> = H extends {
+  readonly traits?: infer S;
+} ? NonNullable<S> extends {
+  readonly $types?: infer T;
+} ? NonNullable<T> extends EntityTraits ? NonNullable<T> : never : never : never;
+type PatternOf<P extends readonly unknown[], Acc = never> = P extends readonly [infer H, ...infer R] ? PatternOf<R, Acc | Declared<TraitsOf<H>['governs'], unknown>> : Acc;
+type TraitGoverned<P extends readonly unknown[], O> = [PatternOf<P>] extends [never] ? false : O extends PatternOf<P> ? true : false;
+type TraitManaged<P extends readonly unknown[], O, Acc = never> = P extends readonly [infer H, ...infer R] ? [TraitsOf<H>] extends [never] ? TraitManaged<R, O, Acc> : TraitManaged<R, O, Acc | Declared<(TraitsOf<H> & {
+  readonly given: O;
+})['managed'], string>> : Acc;
+type TraitOperationNames<P extends readonly unknown[], Acc = never> = P extends readonly [infer H, ...infer R] ? TraitOperationNames<R, Acc | Declared<TraitsOf<H>['operations'], string>> : Acc;
+type RulesOf<H> = [TraitsOf<H>] extends [never] ? {} : TraitsOf<H>['rules'] extends (infer T) ? string extends keyof T ? {} : T : {};
+type AllTraitRules<P extends readonly unknown[], Acc = {}> = P extends readonly [infer H, ...infer R] ? AllTraitRules<R, Acc & RulesOf<H>> : Acc;
+type RulesOnOf<H, O> = (TraitsOf<H> & {
+  readonly given: O;
+})['rulesOn'];
+type TraitRules<P extends readonly unknown[], O, Acc = {}> = P extends readonly [infer H, ...infer R] ? TraitRules<R, O, Acc & Pick<RulesOf<H>, RulesOnOf<H, O> & keyof RulesOf<H>>> : Acc;
+type HookArgsOf<H, S, G extends HookArgGroup> = [TraitsOf<H>] extends [never] ? {} : (TraitsOf<H> & {
+  readonly row: S;
+})['hookArgs'] extends { readonly [K in G]?: infer A; } ? object extends NonNullable<A> ? {} : NonNullable<A> : {};
+type TraitHookArgs<P extends readonly unknown[], S, G extends HookArgGroup, Acc = {}> = P extends readonly [infer H, ...infer R] ? TraitHookArgs<R, S, G, Acc & HookArgsOf<H, S, G>> : Acc;
+type GroupOf<H, G extends OptionGroup> = [TraitsOf<H>] extends [never] ? {} : TraitsOf<H>['optionTypes'] extends { readonly [K in G]: infer T; } ? T : {};
+type AppliesOn<H, O> = (TraitsOf<H> & {
+  readonly given: O;
+})['optionsOn'];
+type TraitOptions<P extends readonly unknown[], O, G extends OptionGroup, Acc = {}> = P extends readonly [infer H, ...infer R] ? [TraitsOf<H>] extends [never] ? TraitOptions<R, O, G, Acc> : TraitOptions<R, O, G, G extends AppliesOn<H, O> ? Acc & GroupOf<H, G> : Acc> : Acc;
+type AllTraitOptions<P extends readonly unknown[], G extends OptionGroup, Acc = {}> = P extends readonly [infer H, ...infer R] ? AllTraitOptions<R, G, Acc & GroupOf<H, G>> : Acc;
+type TraitEntityOptions<P extends readonly unknown[], T, Acc = {}> = P extends readonly [infer H, ...infer R] ? [TraitsOf<H>] extends [never] ? TraitEntityOptions<R, T, Acc> : TraitEntityOptions<R, T, Acc & (TraitsOf<H> & {
+  readonly table: T;
+})['entityOptions']> : Acc;
+type MethodsFold<P extends readonly unknown[], In, K extends 'api' | 'queries', Acc = {}> = P extends readonly [infer H, ...infer R] ? [TraitsOf<H>] extends [never] ? MethodsFold<R, In, K, Acc> : MethodsFold<R, In, K, Acc & (TraitsOf<H> & In)[K]> : Acc;
+type TraitApi<TE extends TypionTypes, N extends EntityName<TE>, TMode extends TypionMode> = MethodsFold<TE['plugins'], {
+  readonly given: TE['entities'][N]['options'];
+  readonly te: TE;
+  readonly name: N;
+  readonly mode: TMode;
+}, 'api'>;
+type TraitQueries<TE extends TypionTypes, N extends EntityName<TE>> = MethodsFold<TE['plugins'], {
+  readonly given: TE['entities'][N]['options'];
+  readonly te: TE;
+  readonly name: N;
+  readonly mode: 'user';
+}, 'queries'>;
+type Values = Readonly<Record<string, unknown>>;
+type TraitContext = BaseContext & Values;
+type TraitFilter = Values;
+type HookArgValues = { readonly [G in HookArgGroup]?: Values; };
+type DerivedTable = {
+  readonly table: PgTable;
+  readonly mirror?: boolean;
+};
+type TraitDeriveInput = {
+  readonly entity: string;
+  readonly table: PgTable;
+  readonly options: Values;
+  readonly schema: PgSchema<string>;
+};
+type TraitResolveInput = {
+  readonly entity: string;
+  readonly table: PgTable;
+  readonly columns: Readonly<Record<string, AnyPgColumn>>;
+  readonly options: Values;
+  readonly derived: Readonly<Record<string, PgTable>>;
+};
+type TraitResolved = {
+  readonly state?: unknown;
+  readonly managed?: readonly string[];
+  readonly options?: readonly OptionGroup[];
+  readonly rules?: readonly string[];
+};
+type TraitFilterInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly operation: Operation;
+  readonly writing: boolean;
+  readonly options: Values;
+  readonly ctx: TraitContext;
+};
+type TraitPartitionInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly operation: Operation;
+  readonly ctx: TraitContext;
+};
+type TraitSourceInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly operation: Operation;
+  readonly options: Values;
+  readonly ctx: TraitContext;
+};
+type TraitSource = {
+  readonly table: string;
+  readonly filter?: TraitFilter;
+  readonly rule?: string;
+};
+type TraitCreateInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly options: Values;
+  readonly row: Values;
+  readonly now: Date;
+  readonly ctx: TraitContext;
+};
+type TraitCreatePlan = {
+  readonly set?: Values;
+  readonly rules?: readonly string[];
+  readonly args?: HookArgValues;
+};
+type TraitUpdateInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly operation: Operation;
+  readonly options: Values;
+  readonly row: AnyRow;
+  readonly tx: AnyTx;
+  readonly ctx: TraitContext;
+};
+type TraitUpdatePlan = {
+  readonly base?: AnyRow;
+  readonly keep?: boolean;
+  readonly args?: HookArgValues;
+};
+type TraitRecordInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly operation: Operation;
+  readonly step: 'create' | 'update' | 'delete';
+  readonly row: AnyRow;
+  readonly previous: AnyRow | null;
+  readonly written: boolean;
+  readonly options: Values;
+  readonly now: Date;
+  readonly tx: AnyTx;
+  readonly ctx: TraitContext;
+};
+type TraitRemoveInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly options: Values;
+  readonly row: AnyRow;
+  readonly now: Date;
+  readonly update: (patch: Values) => Promise<AnyRow>;
+};
+type KitPatchInput = {
+  readonly row: AnyRow;
+  readonly tx: AnyTx;
+  readonly now: Date;
+  readonly ctx: TraitContext;
+};
+type KitReadInput = {
+  readonly executor: AnyDb | AnyTx;
+  readonly partition: Values;
+  readonly now: Date;
+  readonly ctx: TraitContext;
+};
+type OperationKit = {
+  update(id: unknown, patch: Values | ((input: KitPatchInput) => Values | undefined | Promise<Values | undefined>), options?: {
+    readonly rule?: string;
+    readonly options?: Values;
+  }): Promise<AnyRow>;
+  read<T>(fn: (input: KitReadInput) => Promise<T>, options?: {
+    readonly rule?: string;
+  }): Promise<T>;
+};
+type TraitOperationInput = {
+  readonly entity: EntityMeta;
+  readonly state: unknown;
+  readonly input: Values;
+  readonly kit: OperationKit;
+};
+type TraitOperation = {
+  readonly args: readonly string[];
+  readonly options?: Readonly<Record<string, OptionType>>;
+  readonly route?: {
+    readonly method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+    readonly path: string;
+  };
+  readonly run: (input: TraitOperationInput) => Promise<unknown>;
+};
+type TraitsSpec<TTraits extends EntityTraits = EntityTraits> = {
+  readonly $types?: TTraits;
+  readonly options?: { readonly [G in OptionGroup]?: Readonly<Record<string, OptionType>>; };
+  readonly rules?: Readonly<Record<string, RuleKind>>;
+  readonly hookArgs?: HookArgValues;
+  readonly derive?: (input: TraitDeriveInput) => Readonly<Record<string, DerivedTable>> | null;
+  readonly resolve?: (input: TraitResolveInput) => TraitResolved | null;
+  readonly filter?: (input: TraitFilterInput) => TraitFilter | undefined;
+  readonly partition?: (input: TraitPartitionInput) => Values | undefined;
+  readonly source?: (input: TraitSourceInput) => TraitSource | undefined;
+  readonly create?: (input: TraitCreateInput) => TraitCreatePlan | undefined;
+  readonly update?: (input: TraitUpdateInput) => TraitUpdatePlan | undefined | Promise<TraitUpdatePlan | undefined>;
+  readonly remove?: (input: TraitRemoveInput) => Promise<AnyRow> | undefined;
+  readonly record?: (input: TraitRecordInput) => Promise<Values | undefined | void>;
+  readonly operations?: Readonly<Record<string, TraitOperation>>;
+};
+type EntityTrait = {
+  readonly plugin: string;
+  readonly state: unknown;
+  readonly options: readonly OptionGroup[];
+  readonly rules: readonly string[];
+};
+//#endregion
+//#region src/schema/columns.d.ts
+declare function defaultIdColumn(): import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgUUIDBuilder>>;
+declare function timestamps(): {
+  createdAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>;
+  updatedAt: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>>;
+};
+//#endregion
+//#region src/define/engine.d.ts
+type UserTables = Record<string, PgTable | PgEnum<any>>;
+type AllTables<T extends UserTables, P extends readonly AnyPlugin[]> = ExtractTablesFromSchema<T & PluginTables<P>>;
+type MergedRelations<C, P extends readonly AnyPlugin[], T extends UserTables> = ExtractTablesWithRelations<[P[number]] extends [never] ? C & {} : MergeConfigs<MergeAll<P>, C>, AllTables<T, P>>;
+//#endregion
+//#region src/contract/jsonified.d.ts
+type Jsonified<T> = T extends Date | bigint ? string : T extends ((...args: never[]) => unknown) ? never : T extends readonly (infer E)[] ? Jsonified<E>[] : T extends object ? { [K in keyof T]: Jsonified<T[K]>; } : T;
+//#endregion
+//#region src/define/collection.d.ts
+declare function collection<const N extends string, const C extends Record<string, AnyPgColumnBuilder>, const S extends StructureInput<RegisteredPlugins, C, S>>(name: N, structure: S & {
+  columns: C;
+} & NoUnknownKeys<S, StructureInput<RegisteredPlugins, C, S>>): CollectionDraft<N, TableOf<N, S, FoldKinds<RegisteredPlugins, S, 'columns'>>, S>;
+//#endregion
+//#region src/define/plugin.d.ts
+type PluginSpecInput<TId extends string, TTables extends Record<string, PgTable>, TRequires extends Record<string, PgTable>, TCtx extends object, TApi, TEntityOptions extends object, TErrors extends Record<string, PluginErrorDef>, TEntities extends Record<string, EntityDef<string, unknown>>, TRelations extends RelationsBuilderConfig<TTables & TRequires>, TKinds extends CollectionKinds = CollectionKinds, TCollectionOptions extends object = {}, TSystemOptions extends object = {}, TNeedsCtx extends object = {}, TColumnKinds extends ColumnKindsTypes = never, TContextOptions extends object = {}, TTraits extends EntityTraits = never, TDependsOn extends string = never, TFeatureTables extends AnyFeatureTables = {}> = Omit<PluginSpec<TId, TTables, TRequires, TCtx, TApi, TEntityOptions, TErrors, TKinds, TCollectionOptions, TSystemOptions, TNeedsCtx, TColumnKinds, TContextOptions, TTraits, TDependsOn, TFeatureTables>, 'entities' | 'relations'> & {
+  relations?: (r: RelationsBuilder<TTables & TRequires>) => TRelations;
+  entities?: (define: PluginEntityDefiner<TTables>) => TEntities;
+};
+interface DefinedPlugin<TId extends string, TTables extends Record<string, PgTable>, TRequires extends Record<string, PgTable>, TCtx extends object, TApi, TEntityOptions extends object, TErrors extends Record<string, PluginErrorDef>, TEntities extends Record<string, EntityDef<string, unknown>>, TRelations extends RelationsBuilderConfig<TTables & TRequires>, TKinds extends CollectionKinds, TCollectionOptions extends object, TSystemOptions extends object, TNeedsCtx extends object, TColumnKinds extends ColumnKindsTypes, TContextOptions extends object, TTraits extends EntityTraits, TDependsOn extends string, TFeatureTables extends AnyFeatureTables = {}> extends Plugin<PluginSpecInput<TId, TTables, TRequires, TCtx, TApi, TEntityOptions, TErrors, TEntities, TRelations, TKinds, TCollectionOptions, TSystemOptions, TNeedsCtx, TColumnKinds, TContextOptions, TTraits, TDependsOn, TFeatureTables>> {}
+type Guard<T> = [T] extends [infer X extends T] ? X : never;
+declare function definePlugin<const TId extends string, TTables extends Record<string, PgTable> = {}, TRequires extends Record<string, PgTable> = {}, TCtx extends object = {}, TApi = {}, TEntityOptions extends object = {}, const TErrors extends Record<string, PluginErrorDef> = {}, TEntities extends Record<string, EntityDef<string, unknown>> = {}, TRelations extends RelationsBuilderConfig<TTables & TRequires> = {}, TKinds extends CollectionKinds = CollectionKinds, TCollectionOptions extends object = {}, TSystemOptions extends object = {}, TNeedsCtx extends object = {}, TColumnKinds extends ColumnKindsTypes = never, TContextOptions extends object = {}, TDependsOn extends string = never, TFeatureTables extends FeatureTables<TTables> = {}>(spec: PluginSpecInput<TId, TTables, TRequires, TCtx, TApi, TEntityOptions, TErrors, TEntities, TRelations, TKinds, TCollectionOptions, TSystemOptions, TNeedsCtx, TColumnKinds, TContextOptions, never, TDependsOn, TFeatureTables> & {
+  traits?: never;
+}): DefinedPlugin<Guard<TId>, Guard<TTables>, Guard<TRequires>, Guard<TCtx>, Guard<TApi>, Guard<TEntityOptions>, Guard<TErrors>, Guard<TEntities>, Guard<TRelations>, Guard<TKinds>, Guard<TCollectionOptions>, Guard<TSystemOptions>, Guard<TNeedsCtx>, Guard<TColumnKinds>, Guard<TContextOptions>, never, Guard<TDependsOn>, Guard<TFeatureTables>>;
+//#endregion
+//#region src/features/localization.d.ts
+type Localized<T, L extends string, D extends L> = { [K in D]: T; } & { [K in Exclude<L, D>]?: T; } & Kinded<{
+  readonly plugin: 'localization';
+  readonly read: {
+    readonly resolved: T;
+    readonly strict: T | null;
+    readonly all: Localized<T, L, D>;
+  };
+  readonly write: {
+    readonly value: T;
+    readonly all: Localized<T, L, D>;
+  };
+}>;
+type LocaleReadMode = 'resolved' | 'strict' | 'all';
+type StrictOf<C> = C extends {
+  fallback: infer F;
+} ? F extends false ? 'strict' : 'resolved' : 'resolved';
+interface LocalizationReadMode extends ReadModeFn {
+  readonly mode: this['config'] extends {
+    locale: infer L;
+  } ? L extends 'all' ? 'all' : StrictOf<this['config']> : StrictOf<this['config']>;
+}
+interface LocalizationWriteMode extends WriteModeFn {
+  readonly mode: this['config'] extends {
+    locale: infer L;
+  } ? L extends 'all' ? 'all' : 'value' : 'value';
+}
+type LocalizationOptions<L extends readonly [string, ...string[]], D extends L[number]> = {
+  locales: L;
+  defaultLocale: D;
+  fallback?: boolean;
+  locale?: (input: ContextInput) => string | undefined;
+};
+type LocalizationColumnKinds<L extends readonly [string, ...string[]]> = {
+  readMode: LocalizationReadMode;
+  filterMode: 'resolved';
+  writeMode: LocalizationWriteMode;
+  readOptions: {
+    locale?: L[number] | 'all' | undefined;
+    fallback?: boolean | undefined;
+  };
+  writeOptions: {
+    locale?: L[number] | 'all';
+  };
+};
+interface LocalizationPlugin<L extends readonly [string, ...string[]], D extends L[number]> extends DefinedPlugin<'localization', {}, {}, {
+  locale: L[number];
+}, {}, {}, {}, {}, {}, CollectionKinds, {}, {}, {}, LocalizationColumnKinds<L>, {
+  locale?: L[number];
+}, never, never> {
+  readonly locales: L;
+  readonly defaultLocale: D;
+}
+type RegisteredLocalization = Extract<RegisteredPlugins[number], {
+  readonly id: 'localization';
+}>;
+type LocalesOf<P> = P extends {
+  readonly locales: readonly (infer L extends string)[];
+  readonly defaultLocale: infer D extends string;
+} ? {
+  locale: L;
+  default: D;
+} : {
+  locale: string;
+  default: string;
+};
+type LocalizationConfigured = [RegisteredLocalization] extends [never] ? {
+  readonly '~error': 'localized() needs defineSetup({ localization })';
+} : unknown;
+type RegisteredLocale = LocalesOf<RegisteredLocalization>['locale'];
+type RegisteredDefault = LocalesOf<RegisteredLocalization>['default'] & RegisteredLocale;
+type BuilderData<B extends AnyPgColumnBuilder> = B['_'] extends {
+  $type: infer T;
+} ? T : B['_']['data'];
+type JsonSafe<B extends AnyPgColumnBuilder> = BuilderData<B> extends Date | bigint | Uint8Array ? {
+  readonly '~error': 'a localized value is stored as JSON: use text, numbers, booleans, enums or json';
+} : unknown;
+declare function localized<B extends AnyPgColumnBuilder>(builder: B & JsonSafe<B> & LocalizationConfigured): $Type<PgJsonbBuilder, Localized<BuilderData<B>, RegisteredLocale, RegisteredDefault>>;
+declare function localizedValue(column: AnyPgColumn, locale: RegisteredLocale): SQL;
+declare function localizedIndex(name: string, column: AnyPgColumn, locale: RegisteredLocale): IndexBuilder;
+declare function localizedUnique(name: string, column: AnyPgColumn, locale: RegisteredLocale): IndexBuilder;
+//#endregion
+//#region src/features/multi-tenant.d.ts
+declare const COLUMN = "tenantId";
+type TenantIdOf<B> = B extends {
+  readonly _: {
+    readonly $type: infer T;
+  };
+} ? T : B extends {
+  readonly _: {
+    readonly data: infer T;
+  };
+} ? T : unknown;
+type UuidBuilder = SetNotNull<PgUUIDBuilder>;
+type TextBuilder = SetNotNull<PgTextBuilder<[string, ...string[]]>>;
+type IntegerBuilder = SetNotNull<PgIntegerBuilder>;
+interface UuidTenantColumn extends UuidBuilder {}
+interface TextTenantColumn extends TextBuilder {}
+interface IntegerTenantColumn extends IntegerBuilder {}
+type Same<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type TenantColumnOf<B> = Same<B, UuidBuilder> extends true ? UuidTenantColumn : Same<B, TextBuilder> extends true ? TextTenantColumn : Same<B, IntegerBuilder> extends true ? IntegerTenantColumn : B;
+type TenantContext<T = string> = {
+  tenantId: T | null;
+};
+type MultiTenantCollectionOptions = {
+  tenant?: boolean;
+};
+interface MultiTenantKinds<B> extends CollectionKinds {
+  readonly columns: this['options'] extends {
+    tenant: true;
+  } ? {
+    tenantId: B;
+  } : {};
+  readonly entity: this['options'] extends {
+    tenant: true;
+  } ? {
+    tenant: true;
+  } : {};
+}
+type MultiTenantEntityOptions = {
+  tenant?: true;
+};
+type MultiTenantSystemOptions = {
+  unscoped?: boolean;
+};
+type MultiTenantContext = {
+  readonly unscoped: boolean;
+};
+type Enabled$1 = {
+  tenant: true;
+};
+interface MultiTenantTraits extends EntityTraits {
+  readonly entityOptions: MultiTenantEntityOptions;
+  readonly governs: Enabled$1;
+  readonly managed: this['given'] extends Enabled$1 ? typeof COLUMN : never;
+}
+declare function tenantColumn(entity: EntityMeta): string | null;
+type MultiTenantOptions<B extends AnyPgColumnBuilder> = {
+  column: () => B;
+  seedTenant?: TenantIdOf<B>;
+};
+interface MultiTenantPlugin<C, T> extends DefinedPlugin<'multiTenant', {}, {}, MultiTenantContext, {}, {}, {}, {}, {}, MultiTenantKinds<C>, MultiTenantCollectionOptions, MultiTenantSystemOptions, TenantContext<T>, never, {}, MultiTenantTraits, never> {}
+//#endregion
+//#region src/features/soft-delete.d.ts
+declare function softDeleteColumns(): {
+  deletedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+};
+declare function softUnique(name: string, deletedAt: AnyPgColumn): {
+  on(...cols: [AnyPgColumn, ...AnyPgColumn[]]): IndexBuilder;
+};
+type SoftDeleteCollectionOptions = {
+  softDelete?: boolean;
+};
+interface SoftDeleteKinds extends CollectionKinds {
+  readonly columns: this['options'] extends {
+    softDelete: true;
+  } ? ReturnType<typeof softDeleteColumns> : {};
+  readonly entity: this['options'] extends {
+    softDelete: true;
+  } ? {
+    softDelete: true;
+  } : {};
+}
+type SoftDeleteEntityOptions = {
+  softDelete?: true;
+};
+type SoftDeleteReadOptions = {
+  withDeleted?: boolean | undefined;
+};
+type SoftDeleteDeleteOptions = {
+  hard?: boolean;
+};
+type Enabled = {
+  softDelete: true;
+};
+type SoftDeleteApi<T extends EntityTraits> = {
+  restore(id: EntityIdOf<T>): Promise<EntityRowOf<T>>;
+};
+type SoftDeleteQueries<T extends EntityTraits> = {
+  restore(input: {
+    id: EntityIdOf<T>;
+  }): Descriptor<T['name'] & string, 'restore', {
+    id: EntityIdOf<T>;
+  }, EntityRowOf<T>>;
+};
+interface SoftDeleteTraits extends EntityTraits {
+  readonly entityOptions: SoftDeleteEntityOptions;
+  readonly governs: Enabled;
+  readonly managed: this['given'] extends Enabled ? 'deletedAt' : never;
+  readonly optionsOn: this['given'] extends Enabled ? 'read' | 'delete' : never;
+  readonly optionTypes: {
+    read: SoftDeleteReadOptions;
+    delete: SoftDeleteDeleteOptions;
+  };
+  readonly operations: 'restore';
+  readonly api: this['given'] extends Enabled ? SoftDeleteApi<this> : {};
+  readonly queries: this['given'] extends Enabled ? SoftDeleteQueries<this> : {};
+}
+declare function softDeleteColumn(entity: EntityMeta): string | null;
+type SoftDeletePlugin = DefinedPlugin<'softDelete', {}, {}, {}, {}, {}, {}, {}, {}, SoftDeleteKinds, SoftDeleteCollectionOptions, {}, {}, never, {}, SoftDeleteTraits, never>;
+//#endregion
+//#region src/features/versions/table.d.ts
+declare function draftColumns(): {
+  status: import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<["draft", "published"]>>>;
+  publishedAt: import("drizzle-orm/pg-core").PgTimestampBuilder;
+};
+//#endregion
+//#region src/features/versions/index.d.ts
+declare function versionsTable(entity: EntityMeta): PgTable | null;
+type VersionsPlugin = DefinedPlugin<'versions', {}, {}, {}, {}, {}, {}, {}, {}, VersionsKinds, VersionsCollectionOptions, {}, {}, never, {}, VersionsTraits, never>;
+//#endregion
+//#region src/features/index.d.ts
+type Locales = readonly [string, ...string[]];
+type DefaultFeaturePlugins = readonly [VersionsPlugin, SoftDeletePlugin];
+type FeaturePlugins<L, D, B> = readonly [...([L] extends [never] ? [] : [LocalizationPlugin<Assume<L, Locales>, Assume<D, Assume<L, Locales>[number]>>]), VersionsPlugin, SoftDeletePlugin, ...([B] extends [never] ? [] : [MultiTenantPlugin<TenantColumnOf<B>, TenantIdOf<B>>])];
+type FeaturesOptions<L extends Locales, D extends L[number], B extends AnyPgColumnBuilder> = {
+  localization?: LocalizationOptions<L, D>;
+  multiTenant?: MultiTenantOptions<B>;
+};
+//#endregion
+//#region src/define/setup.d.ts
+interface TypionSetup<TPlugins extends readonly AnyPlugin[]> {
+  readonly '~plugins': TPlugins;
+}
+type AnySetup = TypionSetup<readonly AnyPlugin[]>;
+type DefaultSetup = TypionSetup<DefaultFeaturePlugins>;
+interface SetupLocalization<L extends Locales, D extends L[number]> {
+  readonly locales: L;
+  readonly defaultLocale: D;
+}
+type SetupPlugins<L, D, B, P extends readonly AnyPlugin[]> = readonly [...FeaturePlugins<L, D, B>, ...P];
+type Setup<L, D, B, P extends readonly AnyPlugin[]> = TypionSetup<SetupPlugins<L, D, B, P>> & ([L] extends [never] ? {} : {
+  readonly localization: SetupLocalization<Assume<L, Locales>, Assume<D, Assume<L, Locales>[number]>>;
+});
+type SetupOptions<L extends Locales, D extends L[number], B extends AnyPgColumnBuilder, P extends readonly AnyPlugin[]> = FeaturesOptions<L, D, B> & {
+  plugins?: P & DependenciesError<P>;
+};
+declare function defineSetup<const L extends Locales = never, const D extends L[number] = never, B extends AnyPgColumnBuilder = never, const P extends readonly AnyPlugin[] = readonly []>(options: SetupOptions<L, D, B, P>): Setup<L, D, B, P>;
+//#endregion
+//#region src/define/config.d.ts
+declare function defineConfig<S extends AnySetup = DefaultSetup, const Cs extends readonly AnyCollection[] = readonly [], TCtx extends object = {}, const Tb extends ConfigTables = {}>(options: ConfigOptions<S, Cs, TCtx, Tb>): TypionConfig<ConfigTypes<TCtx, S['~plugins'], ByName<Cs>, Tb>>;
+//#endregion
+//#region src/db/adapter.d.ts
+declare function dbAdapter(connect: (relations: AnyRelations) => PgAsyncDatabase<PgQueryResultHKT, any>, options?: {
+  close?: () => Promise<void>;
+  url?: string;
+}): DbAdapter;
+//#endregion
+//#region src/define/entity.d.ts
+declare function allowAll(): AllowAll;
+//#endregion
+//#region src/runtime/internals.d.ts
+type AfterCommitErrorInfo = {
+  readonly entity: string;
+  readonly operation: Operation | 'transaction';
+  readonly requestId: string;
+};
+//#endregion
+//#region src/runtime/typion.d.ts
+type GetTypionOptions = {
+  db?: DbAdapter;
+  fresh?: boolean;
+};
+declare function getTypion<const C extends TypionConfig<any>>(config: C, options?: GetTypionOptions): Promise<Typion<C>>;
+//#endregion
+//#region src/validation/structural.d.ts
+interface StructuralFieldSchema extends StandardSchemaV1 {
+  readonly key: string;
+  readonly required: boolean;
+  readonly nullable: boolean;
+  readonly keyed: boolean;
+}
+interface StructuralSchema extends StandardSchemaV1<Record<string, unknown>, Record<string, unknown>> {
+  readonly entity: string;
+  readonly mode: ValidationMode;
+  readonly fields: Readonly<Record<string, StructuralFieldSchema>>;
+}
+interface StructuralValidationAdapter extends ValidationAdapter {
+  readonly id: 'structural';
+  base(entity: EntityMeta, mode: ValidationMode, refinements: Record<string, unknown> | undefined): StructuralSchema;
+}
+declare function structuralValidation(): StructuralValidationAdapter;
+//#endregion
+//#region src/index.d.ts
+interface Register {}
+//#endregion
+//#region src/types/collection.d.ts
+type RegisteredSetup = Register extends {
+  setup: infer S extends AnySetup;
+} ? S : DefaultSetup;
+type RegisteredPlugins = RegisteredSetup['~plugins'];
+type RegisteredContext = Register extends {
+  context: infer C extends object;
+} ? C : {};
+type RegisteredConfig = Register extends {
+  config: infer C;
+} ? C : never;
+type Registered = ConfigTypesOf<RegisteredConfig>;
+interface RegisteredTypes extends RegisteredTypesBase {}
+type RegisteredTypesBase = [Registered] extends [never] ? TypionTypes : Assume<Registered, TypionTypes>;
+type TypesOf<C> = [C] extends [RegisteredConfig] ? [RegisteredConfig] extends [C] ? RegisteredTypes : OwnTypesOf<C> : OwnTypesOf<C>;
+type OwnTypesOf<C> = C extends {
+  readonly '~types'?: infer TE;
+} ? Assume<NonNullable<TE>, TypionTypes> : never;
+type ConfigTypesOf<C> = C extends {
+  readonly '~types'?: infer TE;
+} ? NonNullable<TE> : never;
+type Flatten<T> = { [K in keyof T]: T[K]; } & {};
+type ApplyKinds<K, O, Key extends 'columns' | 'entity'> = K extends CollectionKinds ? (K & {
+  readonly options: O;
+})[Key] : {};
+type FoldKinds<P extends readonly unknown[], O, Key extends 'columns' | 'entity', Acc = {}> = P extends readonly [infer H, ...infer Rest] ? FoldKinds<Rest, O, Key, Acc & ApplyKinds<PluginKinds<H>, O, Key>> : Acc;
+type IdColumn<S> = S extends {
+  columns: {
+    id: unknown;
+  };
+} ? {} : S extends {
+  idColumn: string;
+} ? {} : {
+  id: ReturnType<typeof defaultIdColumn>;
+};
+type TimestampColumns<S> = S extends {
+  timestamps: false;
+} ? {} : ReturnType<typeof timestamps>;
+type ColumnsOf<S, K> = Flatten<IdColumn<S> & (S extends {
+  columns: infer C;
+} ? C : {}) & TimestampColumns<S> & K>;
+type DbNameOf<N extends string, S> = S extends {
+  dbName: infer D extends string;
+} ? D : N;
+type TableOf<N extends string, S, K> = PgTableWithColumns<{
+  name: DbNameOf<N, S>;
+  schema: undefined;
+  columns: PgBuildColumns<N, Assume<ColumnsOf<S, K>, Record<string, AnyPgColumnBuilder>>>;
+  dialect: 'pg';
+}>;
+type OneSpec<T extends string = string, Opt extends boolean = boolean> = {
+  readonly kind: 'one';
+  readonly target: T;
+  readonly from: string;
+  readonly to: string;
+  readonly optional: Opt;
+};
+type ThroughSpec = {
+  readonly table: string;
+  readonly from: string;
+  readonly to: string;
+};
+type ManySpec<T extends string = string, W extends boolean = boolean> = {
+  readonly kind: 'many';
+  readonly target: T;
+  readonly from: string;
+  readonly to: string;
+  readonly through?: ThroughSpec | undefined;
+  readonly writable: W;
+};
+type RelationSpec = OneSpec | ManySpec;
+type RelationHelpers<TKeys extends string> = {
+  one<const T extends string, const Opt extends boolean = true>(target: T, config: {
+    from: TKeys;
+    to: string;
+    optional?: Opt;
+  }): OneSpec<T, Opt>;
+  many<const T extends string, const W extends boolean = false>(target: T, config: {
+    from: TKeys;
+    to: string;
+    through?: ThroughSpec;
+    writable?: W;
+  }): ManySpec<T, W>;
+};
+type StructureInput<P extends readonly AnyPlugin[], C, S> = {
+  columns: Record<string, AnyPgColumnBuilder>;
+  relations?: (r: RelationHelpers<keyof ColumnsOf<S & {
+    columns: C;
+  }, FoldKinds<P, S & {
+    columns: C;
+  }, 'columns'>> & string>) => Record<string, RelationSpec>;
+  dbName?: string;
+  timestamps?: boolean;
+  public?: boolean;
+  idColumn?: keyof ColumnsOf<S, FoldKinds<P, S, 'columns'>> & string;
+  fields?: { [K in keyof ColumnsOf<S & {
+    columns: C;
+  }, FoldKinds<P, S & {
+    columns: C;
+  }, 'columns'>>]?: FieldOptions<BaseContext & RegisteredContext & PluginNeedsContext<P> & PluginContext<P>>; };
+} & PluginCollectionOptions<P> & PluginEntityOptions<P>;
+type NoUnknownKeys<S, TAllowed> = { [K in Exclude<keyof S, keyof TAllowed>]: never; };
+type RegisteredCtx = [Registered] extends [never] ? BaseContext : Ctx<RegisteredTypes>;
+type OwnRelations<N extends string, T> = ExtractTablesWithRelations<{}, { [K in N]: Assume<T, PgTable>; }>;
+interface RegisteredRelations extends RegisteredRelationsBase {}
+type RegisteredRelationsBase = [Registered] extends [never] ? {} : RegisteredTypes['relations'];
+type RulesRelations<N extends string, T> = [Registered] extends [never] ? OwnRelations<N, T> : N extends keyof RegisteredRelations ? RegisteredRelations : OwnRelations<N, T>;
+type AccessOf<N extends string, T, S, TCtx> = RulesRelations<N, T> extends (infer R extends AnyRelations) ? N extends keyof R & string ? S extends {
+  public: true;
+} ? Omit<AccessRules<R, N, TCtx, RegisteredPlugins, SystemTypion, CollectionRules<S>>, 'read'> : AccessRules<R, N, TCtx, RegisteredPlugins, SystemTypion, CollectionRules<S>> : never : never;
+type CollectionRules<S> = TraitRules<RegisteredPlugins, FoldKinds<RegisteredPlugins, S, 'entity'>>;
+type HooksOf<N extends string, T, TCtx> = RulesRelations<N, T> extends (infer R extends AnyRelations) ? N extends keyof R & string ? EntityHooks<R, N, TCtx, RegisteredPlugins, HookTypion> : never : never;
+type ValidationOf<N extends string, T> = RulesRelations<N, T> extends (infer R extends AnyRelations) ? N extends keyof R & string ? EntityValidation<R, N> : never : never;
+type Behaviour<N extends string, T, S> = {
+  access?: AccessOf<N, T, S, RegisteredCtx>;
+  hooks?: HooksOf<N, T, RegisteredCtx>;
+  validate?: ValidationOf<N, T>;
+  indexes?: (t: { [K in keyof Assume<T, PgTable>['_']['columns']]: ExtraConfigColumn; }) => PgTableExtraConfigValue[];
+  seed?: (generators: SeedGenerators) => Record<string, unknown>;
+  defaultOrder?: Record<string, 'asc' | 'desc'>;
+  maxLimit?: number;
+};
+type CollectionRuntime = {
+  readonly structure: Readonly<Record<string, unknown>>;
+  readonly relations: Readonly<Record<string, RelationSpec>>;
+  readonly behaviour: Readonly<Record<string, unknown>>;
+  readonly state: {
+    table: PgTable | undefined;
+  };
+};
+interface Collection<N extends string, T extends PgTable, S> {
+  readonly name: N;
+  readonly table: T;
+  readonly '~structure': S;
+  readonly '~runtime': CollectionRuntime;
+}
+interface CollectionDraft<N extends string, T extends PgTable, S> extends Collection<N, T, S> {
+  define(behaviour: Behaviour<N, T, S>): Collection<N, T, S>;
+}
+type AnyCollection = {
+  readonly name: string;
+  readonly table: PgTable;
+  readonly '~structure': object;
+  readonly '~runtime': CollectionRuntime;
+};
+type RelationOf<Spec> = Spec extends OneSpec<infer T, infer Opt> ? One<T, Opt> : Spec extends ManySpec<infer T> ? Many<T> : never;
+type RelationsOfStructure<S> = S extends {
+  relations: (r: never) => infer Specs;
+} ? { [K in keyof Specs]: RelationOf<Specs[K]>; } : {};
+type StructureOf<C> = C extends {
+  readonly '~structure': infer S;
+} ? S : never;
+type RelationConfigOf<Cs> = { [K in keyof Cs]: RelationsOfStructure<StructureOf<Cs[K]>>; };
+type TablesOf<Cs> = { [K in keyof Cs]: Cs[K] extends {
+  readonly table: infer T;
+} ? T : never; };
+type ReadOptionOf<S> = S extends {
+  public: true;
+} ? {
+  access: {
+    read: true;
+  };
+} : {
+  access: {
+    read: (a: never) => boolean;
+  };
+};
+type StructureOptionsOf<S> = (S extends {
+  fields: infer Fd;
+} ? {
+  fields: Fd;
+} : {}) & (S extends {
+  idColumn: infer I;
+} ? {
+  idColumn: I;
+} : {}) & LinksOf<S>;
+type LinksOf<S> = S extends {
+  relations: (r: never) => infer Specs;
+} ? WritableOf<Specs> extends (infer L extends string) ? [L] extends [never] ? {} : {
+  links: readonly L[];
+} : {} : {};
+type WritableOf<Specs> = { [K in keyof Specs]: Specs[K] extends {
+  readonly writable: true;
+} ? K : never; }[keyof Specs];
+type EntityOptionsOf<S, K> = Flatten<ReadOptionOf<S> & StructureOptionsOf<S> & K>;
+type EntitiesOf<Cs, P extends readonly unknown[]> = { [K in keyof Cs & string]: EntityDef<K, EntityOptionsOf<StructureOf<Cs[K]>, FoldKinds<P, StructureOf<Cs[K]>, 'entity'>>>; };
+type ConfigTypes<TCtx extends object, P extends readonly AnyPlugin[], Cs, Tb extends ConfigTables = {}> = MergedRelations<RelationConfigOf<Cs>, P, Assume<TablesOf<Cs> & Tb, UserTables>> extends (infer R extends AnyRelations) ? {
+  ctx: TCtx & PluginNeedsContext<P>;
+  tables: TablesOf<Cs> & Tb & Record<string, PgTable | PgEnum<any>>;
+  plugins: P;
+  entities: EntitiesOf<Cs, P> & PluginEntities<P>;
+  relations: R;
+} : never;
+type DbAdapter = {
+  connect(relations: AnyRelations): PgAsyncDatabase<PgQueryResultHKT, any>;
+  check?(): void;
+  close?(): Promise<void>;
+  credentials?(): unknown;
+};
+type ConfigSeedOptions = {
+  count?: number;
+  seed?: number;
+  collections?: readonly string[];
+  values?: Readonly<Record<string, unknown>>;
+  refine?: (generators: SeedGenerators) => Record<string, unknown>;
+};
+type MigrationsOptions = {
+  dir?: string;
+  table?: string;
+  schema?: string;
+};
+interface SystemTypion extends RegisteredSystem {}
+type RegisteredSystem = [Registered] extends [never] ? {} : TypionApp<RegisteredTypes, 'system'>;
+interface HookTypion extends RegisteredHook {}
+type RegisteredHook = [Registered] extends [never] ? {} : Omit<TypionApp<RegisteredTypes, 'user'>, '$mode'> & {
+  readonly $mode: TypionMode;
+};
+type ContextFactory<TCtx> = (input: ContextInput & {
+  system: SystemTypion;
+}) => MaybePromise<TCtx>;
+type TypionConfig<TE extends TypionTypes> = {
+  readonly '~types'?: TE;
+  readonly definition: TypionDefinition<TE>;
+  readonly schema: TypionDefinition<TE>['schema'];
+  readonly db: DbAdapter | undefined;
+  readonly context: ContextFactory<object> | undefined;
+  readonly migrations: MigrationsOptions | undefined;
+  readonly seed: ConfigSeedOptions | undefined;
+  readonly onAfterCommitError: AfterCommitErrorHandler | undefined;
+  readonly checkSchema: boolean | undefined;
+};
+type AfterCommitErrorHandler = (error: unknown, info: AfterCommitErrorInfo) => void;
+type ConfigTables = Record<string, PgTable | PgEnum<any>>;
+type ByName<Cs extends readonly AnyCollection[]> = { [C in Cs[number] as C['name']]: C; };
+type SameSetup<S> = [S] extends [RegisteredSetup] ? [RegisteredSetup] extends [S] ? unknown : SetupMismatch : SetupMismatch;
+type SetupMismatch = {
+  '~error': 'setup must be the one in `interface Register { setup }`';
+};
+type ConfigOptions<S extends AnySetup, Cs extends readonly AnyCollection[], TCtx, Tb extends ConfigTables = {}> = {
+  setup?: S & SameSetup<S>;
+  collections: Cs;
+  tables?: Tb;
+  db?: DbAdapter;
+  context?: ContextFactory<TCtx> & ContextFactory<PluginNeedsContext<S['~plugins']>> & ContextFactory<RegisteredContext>;
+  migrations?: MigrationsOptions;
+  seed?: ConfigSeedOptions;
+  maxLimit?: number;
+  validation?: ValidationAdapter;
+  onAfterCommitError?: AfterCommitErrorHandler;
+  checkSchema?: boolean;
+};
+type Typion<C> = TypionEngine<TypesOf<C>>;
+type TypionAppOf<C> = TypionApp<TypesOf<C>, 'user'>;
+type HandlerOptionsOf<C> = HandlerOptions<TypesOf<C>>;
+//#endregion
+//#region src/features/versions/types.d.ts
+type VersionState = 'draft' | 'published';
+type VersionOperation = 'create' | 'update' | 'draft' | 'publish' | 'unpublish' | 'discard' | 'restoreVersion' | 'delete' | (string & {});
+type VersionRef = {
+  versionId: string;
+  versionNumber: number;
+  state: VersionState;
+};
+type Version<TRow> = {
+  versionId: string;
+  versionNumber: number;
+  state: VersionState;
+  operation: VersionOperation;
+  isLatest: boolean;
+  createdAt: Date;
+  createdBy: string | null;
+  mode: TypionMode;
+  systemReason: string | null;
+  requestId: string | null;
+  data: TRow;
+};
+type FieldDiff<TRow> = { [K in keyof TRow]: {
+  field: K;
+  before: TRow[K];
+  after: TRow[K];
+}; }[keyof TRow];
+type HasDraftColumns<T> = T extends {
+  _: {
+    columns: {
+      status: AnyPgColumn;
+      publishedAt: AnyPgColumn;
+    };
+  };
+} ? true : false;
+type PendingDraftPolicy = 'supersede' | 'reject';
+type VersionsEntityOptions<T> = {
+  versions?: true | {
+    drafts?: HasDraftColumns<T> extends true ? boolean : never;
+    max?: number;
+    onPendingDraft?: PendingDraftPolicy;
+    table?: PgTable;
+  };
+};
+type VersionsOption = true | {
+  drafts?: boolean;
+  max?: number;
+  onPendingDraft?: PendingDraftPolicy;
+};
+type VersionsCollectionOptions = {
+  versions?: VersionsOption;
+};
+interface VersionsKinds extends CollectionKinds {
+  readonly columns: this['options'] extends {
+    versions: {
+      drafts: true;
+    };
+  } ? ReturnType<typeof draftColumns> : {};
+  readonly entity: this['options'] extends {
+    versions: infer V;
+  } ? {
+    versions: V;
+  } : {};
+}
+type Versioned = {
+  versions: true | object;
+};
+type Drafts = {
+  versions: {
+    drafts: true;
+  };
+};
+type VersionsReadOptions = {
+  draft?: boolean | undefined;
+};
+type VersionsCreateOptions = {
+  draft?: boolean;
+  publish?: boolean;
+};
+type VersionsUpdateOptions = {
+  draft?: boolean;
+};
+type VersionsListOptions = {
+  limit?: number;
+  offset?: number;
+  state?: VersionState;
+};
+type VersionsRestoreOptions = {
+  draft?: boolean;
+};
+type VersionsHookArgs<TRow> = {
+  change: {
+    draft: boolean;
+  };
+  afterChange: {
+    previousDraft: TRow | null;
+    version: VersionRef | null;
+  };
+  afterDelete: {
+    version: VersionRef | null;
+  };
+};
+type DraftsApi<T extends EntityTraits> = {
+  publish(id: EntityIdOf<T>): Promise<EntityRowOf<T>>;
+  unpublish(id: EntityIdOf<T>): Promise<EntityRowOf<T>>;
+  discardDraft(id: EntityIdOf<T>): Promise<EntityRowOf<T>>;
+};
+type HistoryApi<T extends EntityTraits> = {
+  versions: {
+    list(id: EntityIdOf<T>, options?: VersionsListOptions): Promise<Version<EntitySelectOf<T>>[]>;
+    get(id: EntityIdOf<T>, versionId: string): Promise<Version<EntitySelectOf<T>>>;
+    restore(id: EntityIdOf<T>, versionId: string, options?: VersionsRestoreOptions): Promise<EntityRowOf<T>>;
+    diff(id: EntityIdOf<T>, from: string, to: string): Promise<FieldDiff<EntitySelectOf<T>>[]>;
+  };
+};
+type IdInput<T extends EntityTraits> = {
+  id: EntityIdOf<T>;
+};
+type Named<T extends EntityTraits> = T['name'] & string;
+type ListInput<T extends EntityTraits> = IdInput<T> & VersionsListOptions;
+type GetInput<T extends EntityTraits> = IdInput<T> & {
+  versionId: string;
+};
+type RestoreInput<T extends EntityTraits> = GetInput<T> & VersionsRestoreOptions;
+type DiffInput<T extends EntityTraits> = IdInput<T> & {
+  from: string;
+  to: string;
+};
+type DraftsQueries<T extends EntityTraits> = {
+  publish(input: IdInput<T>): Descriptor<Named<T>, 'publish', IdInput<T>, EntityRowOf<T>>;
+  unpublish(input: IdInput<T>): Descriptor<Named<T>, 'unpublish', IdInput<T>, EntityRowOf<T>>;
+  discardDraft(input: IdInput<T>): Descriptor<Named<T>, 'discardDraft', IdInput<T>, EntityRowOf<T>>;
+};
+type HistoryQueries<T extends EntityTraits> = {
+  versions: {
+    list(input: ListInput<T>): Descriptor<Named<T>, 'versions.list', ListInput<T>, Version<EntitySelectOf<T>>[]>;
+    get(input: GetInput<T>): Descriptor<Named<T>, 'versions.get', GetInput<T>, Version<EntitySelectOf<T>>>;
+    restore(input: RestoreInput<T>): Descriptor<Named<T>, 'versions.restore', RestoreInput<T>, EntityRowOf<T>>;
+    diff(input: DiffInput<T>): Descriptor<Named<T>, 'versions.diff', DiffInput<T>, FieldDiff<EntitySelectOf<T>>[]>;
+  };
+};
+interface VersionsTraits extends EntityTraits {
+  readonly entityOptions: VersionsEntityOptions<EntityTableOf<this>>;
+  readonly governs: Drafts;
+  readonly managed: this['given'] extends Drafts ? 'status' | 'publishedAt' : never;
+  readonly optionsOn: this['given'] extends Drafts ? 'read' | 'create' | 'update' : never;
+  readonly optionTypes: {
+    read: VersionsReadOptions;
+    create: VersionsCreateOptions;
+    update: VersionsUpdateOptions;
+  };
+  readonly operations: 'publish' | 'unpublish' | 'discardDraft' | 'versions.restore';
+  readonly rules: {
+    readDrafts: 'filter';
+    readVersions: 'boolean';
+    publish: 'filter';
+  };
+  readonly rulesOn: this['given'] extends Drafts ? 'readDrafts' | 'readVersions' | 'publish' : this['given'] extends Versioned ? 'readVersions' : never;
+  readonly hookArgs: VersionsHookArgs<this['row']>;
+  readonly api: this['given'] extends Drafts ? DraftsApi<this> & HistoryApi<this> : this['given'] extends Versioned ? HistoryApi<this> : {};
+  readonly queries: this['given'] extends Drafts ? DraftsQueries<this> & HistoryQueries<this> : this['given'] extends Versioned ? HistoryQueries<this> : {};
+}
+//#endregion
+//#region src/types/hooks.d.ts
+type ChangeOp = 'create' | 'update';
+type Select_<R extends AnyRelations, N extends keyof R> = Assume<R[N]['table'], {
+  $inferSelect: Record<string, unknown>;
+}>['$inferSelect'];
+type Insert_<R extends AnyRelations, N extends keyof R> = Assume<R[N]['table'], {
+  $inferInsert: Record<string, unknown>;
+}>['$inferInsert'];
+type CreateInput_<R extends AnyRelations, N extends keyof R> = Insert_<R, N>;
+type UpdateInput_<R extends AnyRelations, N extends keyof R> = Partial<Insert_<R, N>>;
+type HookBase<R extends AnyRelations, Ctx, TApp = TypionHookApp<R, Ctx>> = {
+  ctx: Ctx;
+  meta: OperationMeta;
+  typion: TApp;
+  tx: PgAsyncTransaction<PgQueryResultHKT, any>;
+  bag: Map<string, unknown>;
+};
+interface TypionHookEntityApi<R extends AnyRelations, N extends keyof R & string> {
+  find<const C extends DBQueryConfig<'many', R, R[N]>>(config?: KnownKeysOnly<C, DBQueryConfig<'many', R, R[N]>>): Promise<BuildQueryResult<R, R[N], C>[]>;
+  findOne<const C extends DBQueryConfig<'one', R, R[N]>>(config?: KnownKeysOnly<C, DBQueryConfig<'one', R, R[N]>>): Promise<BuildQueryResult<R, R[N], C> | null>;
+  findById<const C extends Omit<DBQueryConfig<'one', R, R[N]>, 'where' | 'offset'>>(id: unknown, config?: C): Promise<BuildQueryResult<R, R[N], C>>;
+  count(config?: {
+    where?: RawWhere<R, N>;
+  }): Promise<number>;
+  create(data: Insert_<R, N>): Promise<Select_<R, N>>;
+  update(id: unknown, data: Partial<Insert_<R, N>>): Promise<Select_<R, N>>;
+  updateMany(where: RawWhere<R, N>, data: Partial<Insert_<R, N>>, options?: {
+    max?: number;
+  }): Promise<{
+    count: number;
+  }>;
+  delete(id: unknown, options?: Readonly<Record<string, unknown>>): Promise<Select_<R, N>>;
+  deleteMany(where: RawWhere<R, N>, options?: {
+    max?: number;
+  } & Readonly<Record<string, unknown>>): Promise<{
+    count: number;
+  }>;
+}
+type TypionHookApp<R extends AnyRelations, Ctx> = { [N in keyof R & string]: TypionHookEntityApi<R, N>; } & {
+  readonly $ctx: Ctx;
+  readonly $mode: TypionMode;
+  $transaction<T>(fn: (e: TypionHookApp<R, Ctx>) => Promise<T>): Promise<T>;
+};
+type ChangeArgs<S, CI, UI, TOps extends string = never, TArgs = {}> = ({
+  op: 'create';
+  data: CI;
+  original: null;
+} | {
+  op: 'update' | TOps;
+  data: UI;
+  original: S;
+}) & TArgs;
+type AfterChangeArgs<S, TOps extends string = never, TArgs = {}> = {
+  op: ChangeOp | TOps;
+  doc: S;
+  previous: S | null;
+  changes: readonly (keyof S & string)[];
+} & TArgs;
+type EntityHooks<R extends AnyRelations, N extends keyof R & string, Ctx, P extends readonly unknown[] = readonly [], TApp = TypionHookApp<R, Ctx>, S = Select_<R, N>, CI = CreateInput_<R, N>, UI = UpdateInput_<R, N>, TOps extends string = TraitOperationNames<P>, TDelete = AllTraitOptions<P, 'delete'>, TChange = TraitHookArgs<P, S, 'change'>, TAfterChange = TraitHookArgs<P, S, 'afterChange'>, TAfterDelete = TraitHookArgs<P, S, 'afterDelete'>> = {
+  beforeValidate?: (a: ChangeArgs<S, CI, UI, TOps, TChange> & HookBase<R, Ctx, TApp>) => MaybePromise<CI | UI | void>;
+  beforeChange?: (a: ChangeArgs<S, CI, UI, TOps, TChange> & HookBase<R, Ctx, TApp>) => MaybePromise<CI | UI | void>;
+  afterChange?: (a: AfterChangeArgs<S, TOps, TChange & TAfterChange> & HookBase<R, Ctx, TApp>) => MaybePromise<void>;
+  beforeDelete?: (a: {
+    doc: S;
+    options: TDelete;
+  } & HookBase<R, Ctx, TApp>) => MaybePromise<void>;
+  afterDelete?: (a: {
+    doc: S;
+    options: TDelete;
+  } & TAfterDelete & HookBase<R, Ctx, TApp>) => MaybePromise<void>;
+  afterCommit?: (a: {
+    op: Operation;
+    doc: S | null;
+    previous: S | null;
+    ctx: Ctx;
+    meta: OperationMeta;
+  }) => MaybePromise<void>;
+};
+type AnyRow$1 = Record<string, unknown>;
+type PluginArgs = Readonly<Record<string, unknown>>;
+type CoreArgs = VersionsHookArgs<AnyRow$1>;
+type GlobalHookBase = HookBase<AnyRelations, any> & {
+  entityMeta: EntityMeta;
+};
+type GlobalHooks = {
+  entities?: readonly string[];
+  beforeOperation?: (a: {
+    entity: string;
+    op: Operation;
+    args: unknown;
+  } & GlobalHookBase) => MaybePromise<void>;
+  beforeChange?: (a: {
+    entity: string;
+  } & ChangeArgs<AnyRow$1, AnyRow$1, AnyRow$1, string, PluginArgs & CoreArgs['change']> & GlobalHookBase) => MaybePromise<AnyRow$1 | void>;
+  afterChange?: (a: {
+    entity: string;
+  } & AfterChangeArgs<AnyRow$1, string, PluginArgs & CoreArgs['change'] & CoreArgs['afterChange']> & GlobalHookBase) => MaybePromise<void>;
+  afterDelete?: (a: {
+    entity: string;
+    doc: AnyRow$1;
+    previous: AnyRow$1;
+    removed: boolean;
+    options: Readonly<Record<string, unknown>>;
+  } & PluginArgs & CoreArgs['afterDelete'] & GlobalHookBase) => MaybePromise<void>;
+  afterOperation?: (a: {
+    entity: string;
+    op: Operation;
+    result: unknown;
+  } & GlobalHookBase) => MaybePromise<void>;
+  afterLink?: (a: {
+    entity: string;
+    op: 'link' | 'unlink';
+    doc: AnyRow$1;
+    relation: string;
+    ids: readonly unknown[];
+  } & GlobalHookBase) => MaybePromise<void>;
+  afterCommit?: (a: {
+    entity: string;
+    op: Operation;
+    doc: AnyRow$1 | null;
+    previous: AnyRow$1 | null;
+    ctx: any;
+    meta: OperationMeta;
+  }) => MaybePromise<void>;
+};
+//#endregion
+//#region src/types/access.d.ts
+type RuleSchema<R extends AnyRelations, P extends readonly unknown[]> = { [K in keyof R]: {
+  table: VirtualTable<Assume<R[K]['table'], PgTable>, TableMode<Assume<R[K]['table'], PgTable>, InputModeOf<P>>, never, never>;
+  name: R[K]['name'];
+  relations: R[K]['relations'];
+}; };
+type RuleData<R extends AnyRelations, N extends keyof R> = { [K in keyof Insert_<R, N>]: [KindOf<NonNullable<Insert_<R, N>[K]>>] extends [never] ? Insert_<R, N>[K] : unknown; };
+type RawWhere<R extends AnyRelations, N extends keyof R, P extends readonly unknown[] = readonly []> = RelationsFilter<RuleSchema<R, P>[N], RuleSchema<R, P>>;
+type Operation = 'find' | 'findOne' | 'findById' | 'count' | 'page' | 'create' | 'update' | 'updateMany' | 'delete' | 'deleteMany' | (string & {});
+interface OperationMeta {
+  readonly entity: string;
+  readonly operation: Operation;
+  readonly mode: TypionMode;
+  readonly requestId: string;
+  readonly now: Date;
+  readonly systemReason: string | null;
+}
+type RuleArgs<R extends AnyRelations, Ctx, TApp = TypionHookApp<R, Ctx>> = {
+  ctx: Ctx;
+  meta: OperationMeta;
+  typion: TApp;
+};
+type FilterRule<R extends AnyRelations, N extends keyof R, Ctx, TApp, P extends readonly unknown[], Extra = {}> = boolean | RawWhere<R, N, P> | ((a: RuleArgs<R, Ctx, TApp> & Extra) => MaybePromise<boolean | RawWhere<R, N, P>>);
+type BooleanRule<R extends AnyRelations, Ctx, TApp> = boolean | ((a: RuleArgs<R, Ctx, TApp>) => MaybePromise<boolean>);
+type PluginRules<R extends AnyRelations, N extends keyof R & string, Ctx, TApp, P extends readonly unknown[], TRules> = { [K in keyof TRules]?: TRules[K] extends 'boolean' ? BooleanRule<R, Ctx, TApp> : FilterRule<R, N, Ctx, TApp, P>; };
+type AccessRules<R extends AnyRelations, N extends keyof R & string, Ctx, P extends readonly unknown[] = readonly [], TApp = TypionHookApp<R, Ctx>, TRules = AllTraitRules<P>> = {
+  read?: FilterRule<R, N, Ctx, TApp, P>;
+  create?: boolean | ((a: RuleArgs<R, Ctx, TApp> & {
+    data: RuleData<R, N>;
+  }) => MaybePromise<boolean>);
+  update?: FilterRule<R, N, Ctx, TApp, P, {
+    data: Partial<RuleData<R, N>>;
+  }>;
+  delete?: FilterRule<R, N, Ctx, TApp, P, {
+    options: AllTraitOptions<P, 'delete'>;
+  }>;
+} & PluginRules<R, N, Ctx, TApp, P, TRules>;
+type AnyAccessRules = Readonly<Record<string, unknown>>;
+type AllowAll = {
+  read: true;
+  create: true;
+  update: true;
+  delete: true;
+};
+//#endregion
+//#region src/types/meta.d.ts
+interface ColumnMeta {
+  readonly key: string;
+  readonly name: string;
+  readonly column: AnyPgColumn;
+  readonly dataType: string;
+  readonly columnType: string;
+  readonly notNull: boolean;
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly enumValues: readonly string[] | undefined;
+  readonly kind: string | null;
+  readonly columnKind: ColumnKindRuntime | null;
+  readonly read: true | false | ((a: FieldRuleArgs<any>) => boolean);
+  readonly write: 'user' | 'system' | false | ((a: FieldRuleArgs<any>) => boolean);
+}
+interface RelationMeta {
+  readonly key: string;
+  readonly target: string;
+  readonly type: 'one' | 'many';
+  readonly optional: boolean;
+  readonly through: boolean;
+}
+interface EntityMeta {
+  readonly name: string;
+  readonly table: PgTable;
+  readonly tableName: string;
+  readonly pgSchema: string | undefined;
+  readonly pk: ColumnMeta;
+  readonly columns: Readonly<Record<string, ColumnMeta>>;
+  readonly visibleKeys: readonly string[];
+  readonly kindKeys: readonly string[];
+  readonly dynamicReadKeys: readonly string[];
+  readonly managedKeys: readonly string[];
+  readonly relations: Readonly<Record<string, RelationMeta>>;
+  readonly links: ReadonlySet<string>;
+  readonly traits: Readonly<Record<string, EntityTrait>>;
+  readonly access: AnyAccessRules;
+  readonly hooks: EntityHooks<AnyRelations, string, any>;
+  readonly validate: {
+    insert?: StandardSchemaV1;
+    update?: StandardSchemaV1;
+    fields?: Record<string, unknown>;
+  } | null;
+  readonly defaultOrder: Readonly<Record<string, 'asc' | 'desc'>> | null;
+  readonly maxLimit: number;
+  readonly pluginOptions: Readonly<Record<string, unknown>>;
+  readonly owner: 'user' | {
+    readonly plugin: string;
+  };
+}
+interface TypionDefinition<TE extends TypionTypes> {
+  readonly $types: TE;
+  readonly relations: TE['relations'];
+  readonly schema: Readonly<Record<string, PgTable | PgEnum<any> | PgSchema<string>>>;
+  readonly generated: GeneratedTables<TE> & {
+    readonly $names: readonly string[];
+  };
+  readonly entities: Readonly<Record<EntityName<TE>, EntityMeta>>;
+  readonly plugins: readonly PluginRuntime[];
+  readonly pgSchema: PgSchema<string>;
+  readonly maxLimit: number;
+  readonly validation: ValidationAdapter | null;
+}
+type GeneratedTables<TE extends TypionTypes> = PluginTables<TE['plugins']> & Readonly<Record<string, PgTable>>;
+//#endregion
+//#region src/types/runtime.d.ts
+type AnyDb = PgAsyncDatabase<PgQueryResultHKT, AnyRelations>;
+type AnyTx = PgAsyncTransaction<PgQueryResultHKT, AnyRelations>;
+type AnyRow = Record<string, unknown>;
+interface AfterCommitQueue {
+  readonly size: number;
+  flush(): Promise<void>;
+  discard(): void;
+}
+interface AnyTypionApp {
+  readonly $ctx: BaseContext & Record<string, unknown>;
+  readonly $mode: TypionMode;
+  readonly $tx: AnyTx | null;
+  readonly $engine: AnyTypion;
+  readonly $executor: AnyDb | AnyTx;
+  $run(descriptor: AnyDescriptor, extend?: Record<string, unknown>): Promise<unknown>;
+  $transaction<T>(fn: (bound: AnyTypionApp) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+  $withTx(tx: AnyTx): AnyTypionApp;
+  readonly $afterCommit: AfterCommitQueue;
+  entity(name: string): Record<string, unknown>;
+}
+interface AnyTypion {
+  readonly $def: TypionDefinition<any>;
+  readonly $db: AnyDb;
+  readonly $dialect: Dialect;
+  readonly $plugins: Record<string, unknown>;
+  $as(ctx: object, opts?: {
+    request?: Request;
+    meta?: Record<string, unknown>;
+  } & Record<string, unknown>): AnyTypionApp;
+  $system(opts: {
+    reason: string;
+    ctx?: object;
+    meta?: Record<string, unknown>;
+  } & Record<string, unknown>): AnyTypionApp;
+  $fromRequest(request: Request, opts?: Record<string, unknown>): Promise<AnyTypionApp>;
+  $execute(descriptor: AnyDescriptor, bound: AnyTypionApp): Promise<unknown>;
+}
+interface ValidationAdapter {
+  readonly id: 'structural' | 'zod' | 'valibot' | 'arktype';
+  base(entity: EntityMeta, mode: 'insert' | 'update' | 'select', refinements: Record<string, unknown> | undefined): StandardSchemaV1;
+}
+//#endregion
+//#region src/types/dialect.d.ts
+type SchemaDrift = {
+  missingTables: string[];
+  missingColumns: {
+    table: string;
+    columns: string[];
+  }[];
+};
+interface Dialect {
+  readonly id: 'pg';
+  jsonText(column: AnyPgColumn | SQL, key: string): SQL;
+  cast(value: SQL, type: string): SQL;
+  jsonbMerge(column: AnyPgColumn, patch: unknown): SQL;
+  jsonParam(value: unknown, column: AnyPgColumn): SQL;
+  lockSelect(tx: AnyTx, table: PgTable, where: SQL | undefined): Promise<Record<string, unknown>[]>;
+  mapError(error: unknown): TypionError | null;
+  introspect(db: AnyDb, tables: readonly PgTable[]): Promise<SchemaDrift>;
+}
+//#endregion
+//#region src/contract/errors.d.ts
+declare const ERROR_STATUS: {
+  readonly NOT_FOUND: 404;
+  readonly FORBIDDEN: 403;
+  readonly VALIDATION: 422;
+  readonly CONFLICT: 409;
+  readonly INVALID_STATE: 409;
+  readonly BAD_REQUEST: 400;
+  readonly UNSUPPORTED: 400;
+  readonly PLUGIN: 500;
+  readonly CONFIG: 500;
+  readonly INTERNAL: 500;
+};
+type ErrorStatus = (typeof ERROR_STATUS)[TypionErrorCode];
+type WireIssue = {
+  readonly path: readonly (string | number)[];
+  readonly message: string;
+};
+type WireErrorCode = TypionErrorCode | 'UNAUTHENTICATED';
+type WireError = {
+  readonly code: WireErrorCode;
+  readonly status: number;
+  readonly message: string;
+  readonly entity?: string;
+  readonly issues?: readonly WireIssue[];
+  readonly details?: Record<string, unknown>;
+};
+type WireErrorEnvelope = {
+  readonly error: WireError;
+};
+type WireDataEnvelope<T> = {
+  readonly data: T;
+};
+type WireEnvelope<T> = WireDataEnvelope<T> | WireErrorEnvelope;
+type WireBatchEnvelope<T = unknown> = {
+  readonly results: readonly WireEnvelope<T>[];
+};
+//#endregion
+//#region src/http/transport.d.ts
+type CheckedDescriptor = AnyDescriptor & {
+  readonly '~checked': true;
+};
+interface Transport {
+  readonly name: string;
+  handle(call: TransportCall): Promise<Response | undefined> | Response | undefined;
+}
+interface TransportCall {
+  readonly request: Request;
+  readonly url: URL;
+  readonly method: string;
+  readonly segments: readonly string[];
+  readonly schema: TransportSchema;
+  body(): Promise<unknown>;
+  descriptor(raw: unknown): CheckedDescriptor;
+  run(descriptor: CheckedDescriptor): Promise<unknown>;
+  respond(status: number, payload: unknown): Response;
+  error(error: unknown): WireError;
+}
+interface TransportSchema {
+  readonly maxLimit: number;
+  entity(name: string): TransportEntity | null;
+  readonly readOptions: ReadonlyMap<string, OptionType>;
+  readonly deleteOptions: ReadonlyMap<string, OptionType>;
+}
+interface TransportEntity {
+  readonly name: string;
+  readonly operations: readonly TransportOperation[];
+}
+interface TransportOperation {
+  readonly name: string;
+  readonly args: readonly string[];
+  readonly options: Readonly<Record<string, OptionType>>;
+  readonly route: {
+    readonly method: string;
+    readonly path: string;
+  } | undefined;
+}
+//#endregion
+//#region src/types/engine.d.ts
+interface TypionTypes {
+  ctx: object;
+  tables: Record<string, PgTable | PgEnum<any>>;
+  plugins: readonly AnyPlugin[];
+  entities: AnyEntities;
+  relations: AnyRelations;
+}
+type EntityName<TE extends TypionTypes> = keyof TE['entities'] & keyof TE['relations'] & string;
+type BindOptions<TE extends TypionTypes> = {
+  request?: Request;
+  meta?: Record<string, unknown>;
+} & PluginContextOptions<TE['plugins']>;
+type DescriptorApi<TE extends TypionTypes, N extends EntityName<TE>> = Pick<EntityApi<TE, N, 'user'>, 'query' | 'queryOne'>;
+type CorsOptions = {
+  origin?: string | readonly string[] | ((origin: string) => boolean);
+  methods?: readonly string[];
+  headers?: readonly string[];
+  credentials?: boolean;
+  maxAge?: number;
+};
+type HandlerOptions<TE extends TypionTypes> = {
+  transports: readonly Transport[];
+  basePath?: string;
+  expose?: readonly EntityName<TE>[];
+  exclude?: readonly EntityName<TE>[];
+  exposeBulk?: boolean;
+  maxLimit?: number;
+  maxDepth?: number;
+  codecs?: readonly ('json' | 'superjson')[];
+  cors?: CorsOptions;
+  debug?: boolean;
+  onError?: (error: unknown) => void;
+};
+type TypionApp<TE extends TypionTypes, TMode extends TypionMode> = { [N in EntityName<TE>]: EntityApi<TE, N, TMode> & TraitApi<TE, N, TMode> & LinkApi<TE, N>; } & {
+  readonly $ctx: Ctx<TE>;
+  readonly $mode: TMode;
+  readonly $tx: PgAsyncTransaction<PgQueryResultHKT, TE['relations']> | null;
+  $run<D extends AnyDescriptor>(descriptor: D, extend?: Extend<TE, D['entity'] & EntityName<TE>>): Promise<InferResult<D>>;
+  $transaction<T>(fn: (app: TypionApp<TE, TMode>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+  readonly $afterCommit: AfterCommitQueue;
+  readonly $plugins: PluginApis<TE['plugins']>;
+};
+type TypionEngine<TE extends TypionTypes> = { [N in EntityName<TE>]: DescriptorApi<TE, N>; } & {
+  $as(ctx: TE['ctx'], opts?: BindOptions<TE>): TypionApp<TE, 'user'>;
+  $system(opts: {
+    reason: string;
+    ctx?: Partial<TE['ctx']>;
+    meta?: Record<string, unknown>;
+  } & PluginContextOptions<TE['plugins']> & PluginSystemOptions<TE['plugins']>): TypionApp<TE, 'system'>;
+  $fromRequest(request: Request, opts?: PluginContextOptions<TE['plugins']>): Promise<TypionApp<TE, 'user'>>;
+  $fromHeaders(headers: Headers, opts?: PluginContextOptions<TE['plugins']>): Promise<TypionApp<TE, 'user'>>;
+  $withTx(ctx: TE['ctx'], tx: PgAsyncTransaction<PgQueryResultHKT, TE['relations']>): TypionApp<TE, 'user'>;
+  $execute<D extends AnyDescriptor>(descriptor: D, bound: TypionApp<TE, TypionMode>): Promise<InferResult<D>>;
+  readonly $plugins: PluginApis<TE['plugins']>;
+  readonly $def: TypionDefinition<TE>;
+  readonly $db: PgAsyncDatabase<PgQueryResultHKT, TE['relations']>;
+  readonly $dialect: Dialect;
+};
+//#endregion
+//#region src/types/context.d.ts
+type TypionMode = 'user' | 'system';
+type MaybePromise<T> = T | Promise<T>;
+type BaseContext = {
+  readonly mode: TypionMode;
+  readonly now: Date;
+  readonly requestId: string;
+  readonly request: Request | null;
+  readonly actorId: string | null;
+  readonly systemReason: string | null;
+  readonly meta: Record<string, unknown>;
+};
+type ContextInput = {
+  request?: Request;
+  headers?: Headers;
+  options?: Readonly<Record<string, unknown>>;
+  callerLookup?: boolean;
+};
+type Ctx<TE extends TypionTypes> = BaseContext & TE['ctx'] & PluginContext<TE['plugins']>;
+type FullCtx<TCtx extends object, P extends readonly AnyPlugin[]> = BaseContext & TCtx & PluginContext<P>;
+//#endregion
+export { AfterChangeArgs as $, InferResult as $a, RequirementsError as $i, MultiTenantPlugin as $n, NullableTimestampKeys as $r, RegisteredContext as $t, Dialect as A, ConfigError as Aa, CollectionSpec as Ai, defineSetup as An, CreateInput as Ar, VersionsTraits as At, EntityMeta as B, PluginError as Ba, PluginContext as Bi, SoftDeleteKinds as Bn, FieldRefinements as Br, ConfigOptions as Bt, WireBatchEnvelope as C, ReadModeOf as Ca, VirtualColumn as Ci, AnySetup as Cn, Jsonified as Cr, VersionsEntityOptions as Ct, WireErrorCode as D, WriteModeOf as Da, AnyPlugin as Di, SetupOptions as Dn, TraitQueries as Dr, VersionsOption as Dt, WireError as E, WriteModeFn as Ea, AnyFeatureTables as Ei, SetupLocalization as En, TraitOptions as Er, VersionsListOptions as Et, AnyTx as F, ForbiddenError as Fa, MergeAll as Fi, versionsTable as Fn, EntityDef as Fr, ByName as Ft, AllowAll as G, UnsupportedError as Ga, PluginErrorFactories as Gi, softDeleteColumn as Gn, LinkApi as Gr, DbAdapter as Gt, RelationMeta as H, TypionError as Ha, PluginEntityDefiner as Hi, SoftDeleteQueries as Hn, HiddenWriteKeys as Hr, ConfigTables as Ht, AnyTypion as I, ForbiddenErrorOptions as Ia, MergeConfigs as Ii, SoftDeleteApi as In, EntityOptions as Ir, Collection as It, OperationMeta as J, attempt as Ja, PluginNeedsContext as Ji, MultiTenantCollectionOptions as Jn, LinkQueries as Jr, HookTypion as Jt, AnyAccessRules as K, ValidationError as Ka, PluginErrorInput as Ki, softUnique as Kn, LinkInput as Kr, FoldKinds as Kt, AnyTypionApp as L, InternalError as La, Plugin as Li, SoftDeleteCollectionOptions as Ln, EntitySchemas as Lr, CollectionDraft as Lt, AfterCommitQueue as M, ConflictError as Ma, DependenciesError as Mi, FeaturePlugins as Mn, DeleteOptions as Mr, AfterCommitErrorHandler as Mt, AnyDb as N, ConflictErrorOptions as Na, FeatureId as Ni, FeaturesOptions as Nn, EntitiesOf$1 as Nr, AnyCollection as Nt, WireErrorEnvelope as O, Attempt as Oa, AnyPluginSpec as Oi, SetupPlugins as On, AnyEntities as Or, VersionsReadOptions as Ot, AnyRow as P, ConflictKind as Pa, FeatureTables as Pi, VersionsPlugin as Pn, EntityApi as Pr, Behaviour as Pt, RuleSchema as Q, InferItem as Qa, PluginTables as Qi, MultiTenantOptions as Qn, NoneIfEmpty as Qr, OneSpec as Qt, ValidationAdapter as R, InvalidStateError as Ra, PluginApis as Ri, SoftDeleteDeleteOptions as Rn, EntityValidation as Rr, CollectionRuntime as Rt, ErrorStatus as S, ReadModeFn as Sa, VS as Si, defineConfig as Sn, collection as Sr, VersionsCreateOptions as St, WireEnvelope as T, ValidationMode as Ta, VirtualTable as Ti, Setup as Tn, timestamps as Tr, VersionsKinds as Tt, TypionDefinition as U, TypionErrorCode as Ua, PluginEntityOptions as Ui, SoftDeleteReadOptions as Un, Id$1 as Ur, ConfigTypes as Ut, GeneratedTables as V, PluginErrorOptions as Va, PluginEntities as Vi, SoftDeletePlugin as Vn, FieldRuleArgs as Vr, ConfigSeedOptions as Vt, AccessRules as W, TypionErrorOptions as Wa, PluginErrorDef as Wi, SoftDeleteTraits as Wn, Insert as Wr, ContextFactory as Wt, RuleArgs as X, AnyDescriptor as Xa, PluginRuntime as Xi, MultiTenantEntityOptions as Xn, ManagedKeys as Xr, MigrationsOptions as Xt, RawWhere as Y, isTypionError as Ya, PluginRoute as Yi, MultiTenantContext as Yn, LinkQueryMethods as Yr, ManySpec as Yt, RuleData as Z, Descriptor as Za, PluginSpec as Zi, MultiTenantKinds as Zn, NoExtraKeys as Zr, NoUnknownKeys as Zt, TransportCall as _, KindedData as _a, Result as _i, GetTypionOptions as _n, localizedUnique as _r, Version as _t, MaybePromise as a, ColumnKindRuntime as aa, UpdateManyOptions as ai, StructureInput as an, TextTenantColumn as ar, HookBase as at, TransportSchema as b, PluginReadOptions as ba, Governed as bi, allowAll as bn, PluginSpecInput as br, VersionState as bt, CorsOptions as c, ColumnKindsSpec as ca, ByIdConfig as ci, ThroughSpec as cn, LocaleReadMode as cr, TypionHookApp as ct, HandlerOptions as d, KeyedShape as da, FindConfig as di, TypionAppOf as dn, LocalizationPlugin as dr, DraftsApi as dt, SeedColumnsInput as ea, ReadRow as ei, RegisteredPlugins as en, Op as eo, MultiTenantSystemOptions as er, ChangeArgs as et, TypionApp as f, KindOf as fa, FirstConfig as fi, TypionConfig as fn, LocalizationReadMode as fr, DraftsQueries as ft, Transport as g, Kinded as ga, ReadOptions as gi, structuralValidation as gn, localizedIndex as gr, PendingDraftPolicy as gt, CheckedDescriptor as h, KindWriteOptions as ha, Page as hi, StructuralValidationAdapter as hn, localized as hr, HistoryQueries as ht, FullCtx as i, COLUMN_KIND as ia, UpdateInput as ii, RelationSpec as in, descriptor as io, TenantIdOf as ir, GlobalHooks as it, SchemaDrift as j, ConfigErrorKind as ja, ColumnKind as ji, DefaultFeaturePlugins as jn, CreateOptions as jr, VersionsUpdateOptions as jt, WireIssue as k, BadRequestError as ka, CollectionKinds as ki, TypionSetup as kn, ColumnKeys as kr, VersionsRestoreOptions as kt, DescriptorApi as l, ColumnKindsTypes as la, CountConfig as li, TypesOf as ln, LocalizationColumnKinds as lr, TypionHookEntityApi as lt, TypionTypes as m, KindWrite as ma, OrderBy as mi, StructuralSchema as mn, Localized as mr, HistoryApi as mt, ContextInput as n, SeedSpec as na, Row as ni, RegisteredTypes as nn, ReadOp as no, TenantColumnOf as nr, CreateInput_ as nt, TypionMode as o, ColumnKindSpec as oa, UpdateOptions as oi, SystemTypion as on, UuidTenantColumn as or, Insert_ as ot, TypionEngine as p, KindRead as pa, InputSchema as pi, Register as pn, LocalizationWriteMode as pr, FieldDiff as pt, Operation as q, ValidationIssue as qa, PluginKinds as qi, IntegerTenantColumn as qn, LinkMethods as qr, HandlerOptionsOf as qt, Ctx as r, TableShape as ra, Select as ri, RelationHelpers as rn, WriteOp as ro, TenantContext as rr, EntityHooks as rt, BindOptions as s, ColumnKindTypes as sa, WriteOptions as si, TableOf as sn, tenantColumn as sr, Select_ as st, BaseContext as t, SeedGenerators as ta, ReferenceOptions as ti, RegisteredSetup as tn, RESULT as to, MultiTenantTraits as tr, ChangeOp as tt, EntityName as u, InputModeOf as ua, Extend as ui, Typion as un, LocalizationOptions as ur, UpdateInput_ as ut, TransportEntity as v, OptionType as va, Where as vi, getTypion as vn, localizedValue as vr, VersionOperation as vt, WireDataEnvelope as w, TableMode as wa, VirtualRelation as wi, DefaultSetup as wn, defaultIdColumn as wr, VersionsHookArgs as wt, ERROR_STATUS as x, PluginSystemOptions as xa, HiddenReadKeys as xi, dbAdapter as xn, definePlugin as xr, VersionsCollectionOptions as xt, TransportOperation as y, PluginContextOptions as ya, DynamicReadKeys as yi, AfterCommitErrorInfo as yn, DefinedPlugin as yr, VersionRef as yt, ColumnMeta as z, NotFoundError as za, PluginCollectionOptions as zi, SoftDeleteEntityOptions as zn, FieldOptions as zr, ColumnsOf as zt };
+//# sourceMappingURL=context-CpLQy7OI.d.ts.map