typion 0.0.0-stage → 0.1.1

package/dist/context-B4e2eREP.d.ts

@@ -0,0 +1,2100 @@
+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 ContextFactoryInput = ContextInput & {
+  system: SystemTypion;
+  db: AnyDb;
+};
+type ContextFactory<TCtx> = (input: ContextFactoryInput) => 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 $, InferItem as $a, PluginTables as $i, MultiTenantOptions as $n, NoneIfEmpty as $r, OneSpec as $t, Dialect as A, BadRequestError as Aa, CollectionKinds as Ai, TypionSetup as An, ColumnKeys as Ar, VersionsTraits as At, EntityMeta as B, NotFoundError as Ba, PluginCollectionOptions as Bi, SoftDeleteEntityOptions as Bn, FieldOptions as Br, ConfigOptions as Bt, WireBatchEnvelope as C, ReadModeFn as Ca, VS as Ci, defineConfig as Cn, collection as Cr, VersionsEntityOptions as Ct, WireErrorCode as D, WriteModeFn as Da, AnyFeatureTables as Di, SetupLocalization as Dn, TraitOptions as Dr, VersionsOption as Dt, WireError as E, ValidationMode as Ea, VirtualTable as Ei, Setup as En, timestamps as Er, VersionsListOptions as Et, AnyTx as F, ConflictKind as Fa, FeatureTables as Fi, VersionsPlugin as Fn, EntityApi as Fr, ByName as Ft, AllowAll as G, TypionErrorOptions as Ga, PluginErrorDef as Gi, SoftDeleteTraits as Gn, Insert as Gr, ContextFactoryInput as Gt, RelationMeta as H, PluginErrorOptions as Ha, PluginEntities as Hi, SoftDeletePlugin as Hn, FieldRuleArgs as Hr, ConfigTables as Ht, AnyTypion as I, ForbiddenError as Ia, MergeAll as Ii, versionsTable as In, EntityDef as Ir, Collection as It, OperationMeta as J, ValidationIssue as Ja, PluginKinds as Ji, IntegerTenantColumn as Jn, LinkMethods as Jr, HandlerOptionsOf as Jt, AnyAccessRules as K, UnsupportedError as Ka, PluginErrorFactories as Ki, softDeleteColumn as Kn, LinkApi as Kr, DbAdapter as Kt, AnyTypionApp as L, ForbiddenErrorOptions as La, MergeConfigs as Li, SoftDeleteApi as Ln, EntityOptions as Lr, CollectionDraft as Lt, AfterCommitQueue as M, ConfigErrorKind as Ma, ColumnKind as Mi, DefaultFeaturePlugins as Mn, CreateOptions as Mr, AfterCommitErrorHandler as Mt, AnyDb as N, ConflictError as Na, DependenciesError as Ni, FeaturePlugins as Nn, DeleteOptions as Nr, AnyCollection as Nt, WireErrorEnvelope as O, WriteModeOf as Oa, AnyPlugin as Oi, SetupOptions as On, TraitQueries as Or, VersionsReadOptions as Ot, AnyRow as P, ConflictErrorOptions as Pa, FeatureId as Pi, FeaturesOptions as Pn, EntitiesOf$1 as Pr, Behaviour as Pt, RuleSchema as Q, Descriptor as Qa, PluginSpec as Qi, MultiTenantKinds as Qn, NoExtraKeys as Qr, NoUnknownKeys as Qt, ValidationAdapter as R, InternalError as Ra, Plugin as Ri, SoftDeleteCollectionOptions as Rn, EntitySchemas as Rr, CollectionRuntime as Rt, ErrorStatus as S, PluginSystemOptions as Sa, HiddenReadKeys as Si, dbAdapter as Sn, definePlugin as Sr, VersionsCreateOptions as St, WireEnvelope as T, TableMode as Ta, VirtualRelation as Ti, DefaultSetup as Tn, defaultIdColumn as Tr, VersionsKinds as Tt, TypionDefinition as U, TypionError as Ua, PluginEntityDefiner as Ui, SoftDeleteQueries as Un, HiddenWriteKeys as Ur, ConfigTypes as Ut, GeneratedTables as V, PluginError as Va, PluginContext as Vi, SoftDeleteKinds as Vn, FieldRefinements as Vr, ConfigSeedOptions as Vt, AccessRules as W, TypionErrorCode as Wa, PluginEntityOptions as Wi, SoftDeleteReadOptions as Wn, Id$1 as Wr, ContextFactory as Wt, RuleArgs as X, isTypionError as Xa, PluginRoute as Xi, MultiTenantContext as Xn, LinkQueryMethods as Xr, ManySpec as Xt, RawWhere as Y, attempt as Ya, PluginNeedsContext as Yi, MultiTenantCollectionOptions as Yn, LinkQueries as Yr, HookTypion as Yt, RuleData as Z, AnyDescriptor as Za, PluginRuntime as Zi, MultiTenantEntityOptions as Zn, ManagedKeys as Zr, MigrationsOptions as Zt, TransportCall as _, Kinded as _a, ReadOptions as _i, structuralValidation as _n, localizedIndex as _r, Version as _t, MaybePromise as a, COLUMN_KIND as aa, UpdateInput as ai, RelationSpec as an, descriptor as ao, TenantIdOf as ar, HookBase as at, TransportSchema as b, PluginContextOptions as ba, DynamicReadKeys as bi, AfterCommitErrorInfo as bn, DefinedPlugin as br, VersionState as bt, CorsOptions as c, ColumnKindTypes as ca, WriteOptions as ci, TableOf as cn, tenantColumn as cr, TypionHookApp as ct, HandlerOptions as d, InputModeOf as da, Extend as di, Typion as dn, LocalizationOptions as dr, DraftsApi as dt, RequirementsError as ea, NullableTimestampKeys as ei, RegisteredContext as en, InferResult as eo, MultiTenantPlugin as er, ChangeArgs as et, TypionApp as f, KeyedShape as fa, FindConfig as fi, TypionAppOf as fn, LocalizationPlugin as fr, DraftsQueries as ft, Transport as g, KindWriteOptions as ga, Page as gi, StructuralValidationAdapter as gn, localized as gr, PendingDraftPolicy as gt, CheckedDescriptor as h, KindWrite as ha, OrderBy as hi, StructuralSchema as hn, Localized as hr, HistoryQueries as ht, FullCtx as i, TableShape as ia, Select as ii, RelationHelpers as in, WriteOp as io, TenantContext as ir, GlobalHooks as it, SchemaDrift as j, ConfigError as ja, CollectionSpec as ji, defineSetup as jn, CreateInput as jr, VersionsUpdateOptions as jt, WireIssue as k, Attempt as ka, AnyPluginSpec as ki, SetupPlugins as kn, AnyEntities as kr, VersionsRestoreOptions as kt, DescriptorApi as l, ColumnKindsSpec as la, ByIdConfig as li, ThroughSpec as ln, LocaleReadMode as lr, TypionHookEntityApi as lt, TypionTypes as m, KindRead as ma, InputSchema as mi, Register as mn, LocalizationWriteMode as mr, HistoryApi as mt, ContextInput as n, SeedGenerators as na, ReferenceOptions as ni, RegisteredSetup as nn, RESULT as no, MultiTenantTraits as nr, CreateInput_ as nt, TypionMode as o, ColumnKindRuntime as oa, UpdateManyOptions as oi, StructureInput as on, TextTenantColumn as or, Insert_ as ot, TypionEngine as p, KindOf as pa, FirstConfig as pi, TypionConfig as pn, LocalizationReadMode as pr, FieldDiff as pt, Operation as q, ValidationError as qa, PluginErrorInput as qi, softUnique as qn, LinkInput as qr, FoldKinds as qt, Ctx as r, SeedSpec as ra, Row as ri, RegisteredTypes as rn, ReadOp as ro, TenantColumnOf as rr, EntityHooks as rt, BindOptions as s, ColumnKindSpec as sa, UpdateOptions as si, SystemTypion as sn, UuidTenantColumn as sr, Select_ as st, BaseContext as t, SeedColumnsInput as ta, ReadRow as ti, RegisteredPlugins as tn, Op as to, MultiTenantSystemOptions as tr, ChangeOp as tt, EntityName as u, ColumnKindsTypes as ua, CountConfig as ui, TypesOf as un, LocalizationColumnKinds as ur, UpdateInput_ as ut, TransportEntity as v, KindedData as va, Result as vi, GetTypionOptions as vn, localizedUnique as vr, VersionOperation as vt, WireDataEnvelope as w, ReadModeOf as wa, VirtualColumn as wi, AnySetup as wn, Jsonified as wr, VersionsHookArgs as wt, ERROR_STATUS as x, PluginReadOptions as xa, Governed as xi, allowAll as xn, PluginSpecInput as xr, VersionsCollectionOptions as xt, TransportOperation as y, OptionType as ya, Where as yi, getTypion as yn, localizedValue as yr, VersionRef as yt, ColumnMeta as z, InvalidStateError as za, PluginApis as zi, SoftDeleteDeleteOptions as zn, EntityValidation as zr, ColumnsOf as zt };
+//# sourceMappingURL=context-B4e2eREP.d.ts.map