sasat 0.21.21 → 0.22.1

package/dist/index.d.mts

@@ -1,1146 +1,1071 @@
-import pkg from 'sqlstring';
-import { GraphQLResolveInfo } from 'graphql/type';
-import Hashids from 'hashids';
-import { NestedPartial as NestedPartial$1 } from 'util/type';
-import { GraphQLResolveInfo as GraphQLResolveInfo$1 } from 'graphql';
-import * as mysql2 from 'mysql2';
+import pkg from "sqlstring";
+import * as _$mysql2_promise0 from "mysql2/promise";
+import { ConnectionOptions, PoolOptions } from "mysql2/promise";
+import { GraphQLResolveInfo } from "graphql";
+import Hashids from "hashids";
+import { GraphQLResolveInfo as GraphQLResolveInfo$1 } from "graphql/type/index.js";
 
-type ComparisonOperators = '=' | '>' | '<' | '>=' | '<=' | '<>';
-type AndOr = 'AND' | 'OR';
-type ComparisonExpression$1<T> = Partial<{
-    [P in keyof T]: T[P] | [ComparisonOperators | 'LIKE' | 'NOT LIKE', T[P]] | ['BETWEEN', T[P], T[P]] | ['IN', ...T[P][]] | ['IS NULL'] | ['IS NOT NULL'];
-}> & {
-    __type?: AndOr;
+//#region src/db/connectors/dbClient.d.ts
+type QueryResponse = Array<{
+  [key: string]: SqlValueType;
+}>;
+interface CommandResponse {
+  insertId: number;
+  affectedRows: number;
+  changedRows: number;
+}
+type SqlValueType = string | number | boolean | null;
+interface SQLExecutor {
+  rawQuery(sql: string): Promise<QueryResponse>;
+  rawCommand(sql: string): Promise<CommandResponse>;
+}
+declare abstract class SQLClient implements SQLExecutor {
+  protected logger: (query: string) => void;
+  rawQuery(sql: string): Promise<QueryResponse>;
+  rawCommand(sql: string): Promise<CommandResponse>;
+  query(templateString: TemplateStringsArray, ...params: any[]): Promise<QueryResponse>;
+  command(templateString: TemplateStringsArray, ...params: any[]): Promise<CommandResponse>;
+  protected abstract execSql(sql: string): Promise<QueryResponse | CommandResponse>;
+}
+declare abstract class SQLTransaction extends SQLClient {
+  abstract commit(): Promise<void>;
+  abstract rollback(): Promise<void>;
+}
+declare abstract class DBClient extends SQLClient {
+  protected _released: boolean;
+  protected constructor(logger?: (query: string) => void);
+  isReleased(): boolean;
+  abstract transaction(): Promise<SQLTransaction>;
+  abstract release(): Promise<void>;
+}
+//#endregion
+//#region src/cli/commands/migrate.d.ts
+type MigrateCommandOption = {
+  generateFiles: boolean;
+  silent: boolean;
+  dry: boolean;
+  skipBuild: boolean;
 };
-
+declare const migrate: (client: DBClient, options: MigrateCommandOption) => Promise<void>;
+//#endregion
+//#region src/util/type.d.ts
+type NestedPartial<T> = { [K in keyof T]?: T[K] extends Array<infer R> ? Array<NestedPartial<R>> : NestedPartial<T[K]> };
+//#endregion
+//#region src/config/config.d.ts
+interface SasatConfigDb {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: {
+    ca?: string[];
+  };
+}
+interface SasatConfigMigration {
+  table: string;
+  dir: string;
+  out: string;
+  target?: string;
+  db?: SasatConfigDb;
+}
+interface SasatConfigGenerator {
+  addJsExtToImportStatement: boolean;
+  gql: {
+    subscription: boolean;
+  };
+}
+interface SasatConfig {
+  db: SasatConfigDb;
+  migration: SasatConfigMigration;
+  generator: SasatConfigGenerator;
+}
+declare function setConfig(update: NestedPartial<SasatConfig>): SasatConfig;
+//#endregion
+//#region src/db/connectors/mysql/client.d.ts
+declare class MysqlClient extends DBClient {
+  readonly connectionOption: ConnectionOptions;
+  release(): Promise<void>;
+  constructor(connectionOption: ConnectionOptions, logger?: (query: string) => void);
+  protected getConnection(): Promise<_$mysql2_promise0.Connection>;
+  transaction(): Promise<SQLTransaction>;
+  protected execSql(sql: string): Promise<QueryResponse | CommandResponse>;
+}
+//#endregion
+//#region src/db/formatQuery.d.ts
+declare const formatQuery: (str: TemplateStringsArray, ...params: any[]) => string;
+//#endregion
+//#region src/db/sql/expression/comparison.d.ts
+type ComparisonOperators = "=" | ">" | "<" | ">=" | "<=" | "<>";
+type AndOr = "AND" | "OR";
+type ComparisonExpression$1<T> = Partial<{ [P in keyof T]: T[P] | [ComparisonOperators | "LIKE" | "NOT LIKE", T[P]] | ["BETWEEN", T[P], T[P]] | ["IN", ...T[P][]] | ["IS NULL"] | ["IS NOT NULL"] }> & {
+  __type?: AndOr;
+};
+//#endregion
+//#region src/runtime/dsl/query/query.d.ts
 declare enum QueryNodeKind {
-    Field = 0,
-    Function = 1,
-    Table = 2,
-    Join = 3,
-    CompoundExpr = 4,
-    ComparisonExpr = 5,
-    IsNullExpr = 6,
-    Parenthesis = 7,
-    InExpr = 8,
-    BetweenExpr = 9,
-    ContainsExpr = 10,
-    Literal = 11,
-    Sort = 12,
-    Identifier = 13,
-    Exists = 14,
-    Raw = 15,
-    GroupBy = 16,
-    Over = 17,
-    Window = 18
+  Field = 0,
+  Function = 1,
+  Table = 2,
+  Join = 3,
+  CompoundExpr = 4,
+  ComparisonExpr = 5,
+  IsNullExpr = 6,
+  Parenthesis = 7,
+  InExpr = 8,
+  BetweenExpr = 9,
+  ContainsExpr = 10,
+  Literal = 11,
+  Sort = 12,
+  Identifier = 13,
+  Exists = 14,
+  Raw = 15,
+  GroupBy = 16,
+  Over = 17,
+  Window = 18
 }
-type LockMode = 'FOR UPDATE' | 'FOR SHARE';
+type LockMode = "FOR UPDATE" | "FOR SHARE";
 type Query = {
-    select: SelectExpr[];
-    from: QueryTable;
-    where?: BooleanValueExpression;
-    groupBy?: GroupByExpr;
-    having?: BooleanValueExpression;
-    sort?: Sort[];
-    limit?: number;
-    offset?: number;
-    lock?: LockMode;
+  select: SelectExpr[];
+  from: QueryTable;
+  where?: BooleanValueExpression;
+  groupBy?: GroupByExpr;
+  having?: BooleanValueExpression;
+  sort?: Sort[];
+  limit?: number;
+  offset?: number;
+  lock?: LockMode;
 };
 type GroupByExpr = {
-    kind: QueryNodeKind.GroupBy;
-    cols: (Field | Identifier)[];
+  kind: QueryNodeKind.GroupBy;
+  cols: (Field | Identifier)[];
 };
 type Field = {
-    kind: QueryNodeKind.Field;
-    table: string;
-    name: string;
-    alias?: string;
+  kind: QueryNodeKind.Field;
+  table: string;
+  name: string;
+  alias?: string;
 };
 type Fn = {
-    kind: QueryNodeKind.Function;
-    fnName: string;
-    args: Value[];
-    over?: Over;
-    alias?: string;
+  kind: QueryNodeKind.Function;
+  fnName: string;
+  args: Value[];
+  over?: Over;
+  alias?: string;
 };
 type Over = {
-    kind: QueryNodeKind.Over;
-    orderBy?: Sort[];
-    partitionBy?: Identifier[];
-    window?: Window;
+  kind: QueryNodeKind.Over;
+  orderBy?: Sort[];
+  partitionBy?: Identifier[];
+  window?: Window;
 };
 type Window = {
-    kind: QueryNodeKind.Window;
-    type: 'ROWS' | 'RANGE';
-    between: true;
-    start: WindowContent;
-    end: WindowContent;
+  kind: QueryNodeKind.Window;
+  type: "ROWS" | "RANGE";
+  between: true;
+  start: WindowContent;
+  end: WindowContent;
 } | {
-    kind: QueryNodeKind.Window;
-    type: 'ROWS' | 'RANGE';
-    between: false;
-    value: WindowContent;
+  kind: QueryNodeKind.Window;
+  type: "ROWS" | "RANGE";
+  between: false;
+  value: WindowContent;
 };
-type WINDOW_TYPES_NO_ARG = 'UNBOUNDED PRECEDING' | 'UNBOUNDED FOLLOWING' | 'CURRENT ROW';
-type WINDOW_TYPES_ARG = 'PRECEDING' | 'FOLLOWING';
+type WINDOW_TYPES_NO_ARG = "UNBOUNDED PRECEDING" | "UNBOUNDED FOLLOWING" | "CURRENT ROW";
+type WINDOW_TYPES_ARG = "PRECEDING" | "FOLLOWING";
 type WindowContent = {
-    type: WINDOW_TYPES_NO_ARG;
+  type: WINDOW_TYPES_NO_ARG;
 } | {
-    type: WINDOW_TYPES_ARG;
-    value: number;
+  type: WINDOW_TYPES_ARG;
+  value: number;
 };
 type SelectExpr = Field | Fn | Identifier | RawExpression;
 type QueryTable = {
-    kind: QueryNodeKind.Table;
-    alias: string;
-    joins: Join[];
+  kind: QueryNodeKind.Table;
+  alias: string;
+  joins: Join[];
 } & ({
-    subquery?: false;
-    name: string;
+  subquery?: false;
+  name: string;
 } | {
-    subquery: true;
-    query: Query;
+  subquery: true;
+  query: Query;
 });
-type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'OUTER';
+type JoinType = "INNER" | "LEFT" | "RIGHT" | "OUTER";
 type Join = {
-    kind: QueryNodeKind.Join;
-    type?: JoinType;
-    table: QueryTable;
-    conditions: BooleanValueExpression;
+  kind: QueryNodeKind.Join;
+  type?: JoinType;
+  table: QueryTable;
+  conditions: BooleanValueExpression;
 };
 type ParenthesisExpression = {
-    kind: QueryNodeKind.Parenthesis;
-    expression: BooleanValueExpression;
+  kind: QueryNodeKind.Parenthesis;
+  expression: BooleanValueExpression;
 };
 type RawExpression = {
-    kind: QueryNodeKind.Raw;
-    expr: string;
+  kind: QueryNodeKind.Raw;
+  expr: string;
 };
 type ExistsExpression = {
-    kind: QueryNodeKind.Exists;
-    query: Query | RawExpression;
+  kind: QueryNodeKind.Exists;
+  query: Query | RawExpression;
 };
 type BooleanValueExpression = CompoundExpression | ComparisonExpression | IsNullExpression | ParenthesisExpression | InExpression | BetweenExpression | ContainsExpression | ExistsExpression;
 type IsNullExpression = {
-    kind: QueryNodeKind.IsNullExpr;
-    expr: Value;
-    isNot: boolean;
+  kind: QueryNodeKind.IsNullExpr;
+  expr: Value;
+  isNot: boolean;
 };
-type CompoundOperator = 'AND' | 'OR';
+type CompoundOperator = "AND" | "OR";
 type CompoundExpression = {
-    kind: QueryNodeKind.CompoundExpr;
-    left: BooleanValueExpression;
-    operator: CompoundOperator;
-    right: BooleanValueExpression;
+  kind: QueryNodeKind.CompoundExpr;
+  left: BooleanValueExpression;
+  operator: CompoundOperator;
+  right: BooleanValueExpression;
 };
 type ComparisonExpression = {
-    kind: QueryNodeKind.ComparisonExpr;
-    left: Value;
-    operator: ComparisonOperators;
-    right: Value;
+  kind: QueryNodeKind.ComparisonExpr;
+  left: Value;
+  operator: ComparisonOperators;
+  right: Value;
 };
-type ContainType = 'start' | 'end' | 'contains';
+type ContainType = "start" | "end" | "contains";
 type ContainsExpression = {
-    kind: QueryNodeKind.ContainsExpr;
-    type: ContainType;
-    left: Value;
-    isNot: boolean;
-    right: string;
+  kind: QueryNodeKind.ContainsExpr;
+  type: ContainType;
+  left: Value;
+  isNot: boolean;
+  right: string;
 };
 type InExpression = {
-    kind: QueryNodeKind.InExpr;
-    left: Value;
-    operator: 'IN' | 'NOT IN';
+  kind: QueryNodeKind.InExpr;
+  left: Value;
+  operator: "IN" | "NOT IN";
 } & ({
-    query: Query | RawExpression;
+  query: Query | RawExpression;
 } | {
-    right: Value[];
+  right: Value[];
 });
 type BetweenExpression = {
-    kind: QueryNodeKind.BetweenExpr;
-    left: Value;
-    begin: Value;
-    end: Value;
+  kind: QueryNodeKind.BetweenExpr;
+  left: Value;
+  begin: Value;
+  end: Value;
 };
 type Value = Literal | Field | Fn | Identifier;
 type Identifier = {
-    kind: QueryNodeKind.Identifier;
-    identifier: string;
+  kind: QueryNodeKind.Identifier;
+  identifier: string;
 };
 type Literal = {
-    kind: QueryNodeKind.Literal;
-    value: string | boolean | number | null;
+  kind: QueryNodeKind.Literal;
+  value: string | boolean | number | null;
 };
-type SortDirection = 'ASC' | 'DESC';
+type SortDirection = "ASC" | "DESC";
 type Sort = {
-    kind: QueryNodeKind.Sort;
-    field: Field | Fn | Identifier;
-    direction?: SortDirection;
+  kind: QueryNodeKind.Sort;
+  field: Field | Fn | Identifier;
+  direction?: SortDirection;
 };
-
+//#endregion
+//#region src/runtime/dsl/query/sql/queryToSql.d.ts
 declare const queryToSql: (query: Query) => string;
-
-type NestedPartial<T> = {
-    [K in keyof T]?: T[K] extends Array<infer R> ? Array<NestedPartial<R>> : NestedPartial<T[K]>;
-};
-
-interface SasatConfigDb {
-    host: string;
-    port: number;
-    user: string;
-    password?: string;
-    database: string;
-    ssl?: {
-        ca?: string[];
-    };
-}
-interface SasatConfigMigration {
-    table: string;
-    dir: string;
-    out: string;
-    target?: string;
-    db?: SasatConfigDb;
-}
-interface SasatConfigGenerator {
-    addJsExtToImportStatement: boolean;
-    gql: {
-        subscription: boolean;
-    };
-}
-interface SasatConfig {
-    db: SasatConfigDb;
-    migration: SasatConfigMigration;
-    generator: SasatConfigGenerator;
-}
-declare function setConfig(update: NestedPartial<SasatConfig>): SasatConfig;
-
-declare const formatQuery: (str: TemplateStringsArray, ...params: any[]) => string;
-
-type QueryResponse = Array<{
-    [key: string]: SqlValueType;
-}>;
-interface CommandResponse {
-    insertId: number;
-    affectedRows: number;
-    changedRows: number;
-}
-type SqlValueType = string | number | boolean | null;
-interface SQLExecutor {
-    rawQuery(sql: string): Promise<QueryResponse>;
-    rawCommand(sql: string): Promise<CommandResponse>;
-}
-declare abstract class SQLClient implements SQLExecutor {
-    protected logger: (query: string) => void;
-    rawQuery(sql: string): Promise<QueryResponse>;
-    rawCommand(sql: string): Promise<CommandResponse>;
-    query(templateString: TemplateStringsArray, ...params: any[]): Promise<QueryResponse>;
-    command(templateString: TemplateStringsArray, ...params: any[]): Promise<CommandResponse>;
-    protected abstract execSql(sql: string): Promise<QueryResponse | CommandResponse>;
-}
-declare abstract class SQLTransaction extends SQLClient {
-    abstract commit(): Promise<void>;
-    abstract rollback(): Promise<void>;
-}
-declare abstract class DBClient extends SQLClient {
-    protected _released: boolean;
-    protected constructor(logger?: (query: string) => void);
-    isReleased(): boolean;
-    abstract transaction(): Promise<SQLTransaction>;
-    abstract release(): Promise<void>;
-}
-
+//#endregion
+//#region src/runtime/field.d.ts
 type Fields<Entity, Relation = Record<string, unknown>> = {
-    fields: Array<keyof Entity & string>;
-    relations?: Relation;
-    tableAlias?: string;
-    joinOn?: BooleanValueExpression;
+  fields: Array<keyof Entity & string>;
+  relations?: Relation;
+  tableAlias?: string;
+  joinOn?: BooleanValueExpression;
 };
-
+//#endregion
+//#region src/runtime/dsl/query/createQueryResolveInfo.d.ts
 type MakeConditionArg<Context = unknown, Entity = unknown> = {
-    childTableAlias: string;
-    context?: Context;
+  childTableAlias: string;
+  context?: Context;
 } & ({
-    parentTableAlias: string;
-    parent?: undefined;
+  parentTableAlias: string;
+  parent?: undefined;
 } | {
-    parent: Partial<Entity>;
-    parentTableAlias?: undefined;
+  parent: Partial<Entity>;
+  parentTableAlias?: undefined;
 });
-type MakeCondition<Context, Entity = any> = (arg: MakeConditionArg<Context, Entity>) => BooleanValueExpression;
+type MakeCondition<Context, Entity = unknown> = (arg: MakeConditionArg<Context, Entity>) => BooleanValueExpression;
 type RelationInfo<Context = unknown> = {
-    table: string;
-    condition: MakeCondition<Context>;
-    array: boolean;
-    nullable: boolean;
-    requiredColumns: string[];
+  table: string;
+  condition: MakeCondition<Context>;
+  array: boolean;
+  nullable: boolean;
+  requiredColumns: string[];
 };
 type RelationMap<Context = unknown> = {
-    [from: string]: {
-        [to: string]: RelationInfo<Context>;
-    };
+  [from: string]: {
+    [to: string]: RelationInfo<Context>;
+  };
 };
 type TableInfo = {
-    [tableName: string]: {
-        identifiableKeys: string[];
-        identifiableFields: string[];
-        columnMap: {
-            [fieldName: string]: string;
-        };
+  [tableName: string]: {
+    identifiableKeys: string[];
+    identifiableFields: string[];
+    columnMap: {
+      [fieldName: string]: string;
     };
+  };
 };
-
+//#endregion
+//#region src/runtime/sql/runQuery.d.ts
 type PagingOption$1 = {
-    numberOfItem: number;
-    where?: BooleanValueExpression;
-    offset?: number;
-    sort?: Sort[];
-    join?: Join[];
+  numberOfItem: number;
+  where?: BooleanValueExpression;
+  offset?: number;
+  sort?: Sort[];
+  join?: Join[];
 };
-
+//#endregion
+//#region src/runtime/sasatDBDatasource.d.ts
 type EntityType = Record<string, SqlValueType>;
 type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
 interface Repository<Entity, Identifiable, Creatable, Updatable> {
-    create(entity: Creatable): Promise<Entity>;
-    update(entity: Updatable): Promise<CommandResponse>;
-    delete(entity: Identifiable): Promise<CommandResponse>;
+  create(entity: Creatable): Promise<Entity>;
+  update(entity: Updatable): Promise<CommandResponse>;
+  delete(entity: Identifiable): Promise<CommandResponse>;
 }
 type ListQueryOption = {
-    numberOfItem: number;
-    offset?: number;
-    order?: string;
-    asc?: boolean;
-    join?: Join[];
+  numberOfItem: number;
+  offset?: number;
+  order?: string;
+  asc?: boolean;
+  join?: Join[];
 };
 type QueryOptions = {
-    where?: BooleanValueExpression;
-    sort?: Sort[];
-    limit?: number;
-    offset?: number;
-    lock?: LockMode;
+  where?: BooleanValueExpression;
+  sort?: Sort[];
+  limit?: number;
+  offset?: number;
+  lock?: LockMode;
 };
 declare abstract class SasatDBDatasource<Entity extends EntityType, Identifiable extends object, Creatable extends EntityType, Updatable extends Identifiable, EntityFields extends Fields<Entity>, QueryResult extends Partial<Entity> & Identifiable> implements Repository<Entity, Identifiable, Creatable, Updatable> {
-    protected client: SQLExecutor;
-    protected abstract relationMap: RelationMap<any>;
-    protected abstract tableInfo: TableInfo;
-    abstract readonly tableName: string;
-    abstract readonly fields: string[];
-    protected abstract readonly primaryKeys: string[];
-    protected abstract readonly identifyFields: string[];
-    protected abstract readonly autoIncrementColumn?: string | undefined;
-    protected queryLogger: (sql: string) => void;
-    protected commandLogger: (sql: string) => void;
-    constructor(client?: SQLExecutor);
-    protected abstract getDefaultValueString(): Partial<{
-        [P in keyof Entity]: Entity[P] | string | null | never;
-    }> | never;
-    create(entity: Creatable, option?: {
-        ignore?: boolean;
-        upsert?: {
-            updateColumns: string[];
-        };
-    }): Promise<Entity>;
-    createBulk(entities: Creatable[], option?: {
-        ignore?: boolean;
-        upsert?: {
-            updateColumns: string[];
-        };
-    }): Promise<CommandResponse>;
-    upsert<T extends Creatable & Partial<Entity>>(entity: T, updateFields?: (keyof T)[]): Promise<Entity>;
-    update(entity: Updatable): Promise<CommandResponse>;
-    updateWhere(update: Omit<Updatable, keyof Identifiable>, condition: BooleanValueExpression): Promise<CommandResponse>;
-    delete(entity: Identifiable): Promise<CommandResponse>;
-    deleteWhere(condition: BooleanValueExpression): Promise<CommandResponse>;
-    first(fields?: EntityFields, option?: QueryOptions, context?: unknown): Promise<QueryResult | null>;
-    find(fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
-    findPageable(paging: PagingOption$1, fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
-    private executeQuery;
-    private createIdentifiableExpression;
-    getRelationMap(): {
-        [to: string]: RelationInfo<any>;
+  protected client: SQLExecutor;
+  protected abstract relationMap: RelationMap<unknown>;
+  protected abstract tableInfo: TableInfo;
+  abstract readonly tableName: string;
+  abstract readonly fields: string[];
+  protected abstract readonly primaryKeys: string[];
+  protected abstract readonly identifyFields: string[];
+  protected abstract readonly autoIncrementColumn?: string | undefined;
+  constructor(client?: SQLExecutor);
+  protected abstract getDefaultValueString(): Partial<{ [P in keyof Entity]: Entity[P] | string | null | never }> | never;
+  create(entity: Creatable, option?: {
+    ignore?: boolean;
+    upsert?: {
+      updateColumns: string[];
+    };
+  }): Promise<Entity>;
+  createBulk(entities: Creatable[], option?: {
+    ignore?: boolean;
+    upsert?: {
+      updateColumns: string[];
     };
-    protected fieldToColumn(fields: string[]): string[];
+  }): Promise<CommandResponse>;
+  upsert<T extends Creatable & Partial<Entity>>(entity: T, updateFields?: (keyof T)[]): Promise<Entity>;
+  update(entity: Updatable): Promise<CommandResponse>;
+  updateWhere(update: Omit<Updatable, keyof Identifiable>, condition: BooleanValueExpression): Promise<CommandResponse>;
+  delete(entity: Identifiable): Promise<CommandResponse>;
+  deleteWhere(condition: BooleanValueExpression): Promise<CommandResponse>;
+  first(fields?: EntityFields, option?: QueryOptions, context?: unknown): Promise<QueryResult | null>;
+  find(fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
+  findPageable(paging: PagingOption$1, fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
+  private executeQuery;
+  private createIdentifiableExpression;
+  getRelationMap(): {
+    [to: string]: RelationInfo<unknown>;
+  };
+  protected fieldToColumn(fields: string[]): string[];
 }
-
-declare const Sql: {
-    select: (expr: SelectExpr) => string;
-    literal: (literal: Literal) => string;
-    fieldInCondition: (identifier: Field) => string;
-    fieldInSelect: (identifier: Field) => string;
-    identifier: (ident: Identifier) => string;
-    fn: (fn: Fn) => string;
-    value: (v: Value) => string;
-    between: (expr: BetweenExpression) => string;
-    contains: (expr: ContainsExpression) => string;
-    in: (expr: InExpression) => string;
-    comparison: (expr: ComparisonExpression) => string;
-    compound: (expr: CompoundExpression) => string;
-    isNull: (expr: IsNullExpression) => string;
-    paren: (expr: ParenthesisExpression) => string;
-    table: (table: QueryTable) => string;
-    join: (join: Join) => string;
-    booleanValue: (expr: BooleanValueExpression) => string;
-    exists: (expr: ExistsExpression) => string;
-    sort: (expr: Sort) => string;
-    sorts: (sorts: Sort[]) => string;
-    queryOrRaw: (expr: Query | RawExpression) => string;
-};
-
-declare const escape: typeof pkg.escape;
-declare const SqlString: {
-    escape: (value: Parameters<typeof escape>[0]) => string;
-    escapeId: (name: string) => string;
-};
-
-type ResolverArgs<Context, Params = unknown> = [
-    _: unknown,
-    params: Params,
-    context: Context,
-    info: GraphQLResolveInfo
-];
-type Resolver<Context, Params> = (_: unknown, params: Params, context: Context, info: GraphQLResolveInfo) => unknown;
-declare const makeResolver: <Context, RequiredParams, IncomingParams = RequiredParams>(resolver: Resolver<Context, RequiredParams>, middlewares?: ResolverMiddleware<Context, RequiredParams, IncomingParams>[]) => Resolver<Context, RequiredParams>;
-
-type ResolverMiddleware<Context, RequiredParams = any, IncomingParams = RequiredParams> = (args: ResolverArgs<Context, IncomingParams | RequiredParams>) => ResolverArgs<Context, RequiredParams | IncomingParams>;
-declare const makeParamsMiddleware: <RequiredParams, IncomingParams = RequiredParams>(update: (params: RequiredParams) => IncomingParams) => ResolverMiddleware<never, RequiredParams, IncomingParams>;
-
-type NumberIdEncoder = {
-    encode: (id: number) => string;
-    decode: (id: string) => number;
+//#endregion
+//#region src/db/getDbClient.d.ts
+declare const getDbClient: (option?: Partial<PoolOptions>, logger?: (query: string) => void) => DBClient;
+//#endregion
+//#region src/db/sql/expression/conditionExpression.d.ts
+type ConditionExpression<T> = ComparisonExpression$1<T> | CompositeCondition<T>;
+//#endregion
+//#region src/db/sql/expression/compositeCondition.d.ts
+declare class CompositeCondition<T> {
+  private type;
+  private conditions;
+  private constructor();
+  static or<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
+  static and<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
+  toSQL(): string;
+}
+//#endregion
+//#region src/generatorv2/codegen/ts/scripts/typeDefinition.d.ts
+type TypeFieldDefinition = {
+  return: string;
+  args?: {
+    name: string;
+    type: string;
+  }[];
 };
-declare const makeNumberIdEncoder: (hashId: Hashids) => NumberIdEncoder;
-
-type CustomCondition<Context> = (args: MakeConditionArg<Context>) => BooleanValueExpression;
-
+//#endregion
+//#region src/migration/data/relation.d.ts
+type Relation = "One" | "OneOrZero" | "Many";
+//#endregion
+//#region src/migration/column/columnTypes.d.ts
+declare enum DBColumnTypes {
+  char = "char",
+  varchar = "varchar",
+  text = "text",
+  tinyInt = "tinyint",
+  smallInt = "smallint",
+  mediumInt = "mediumint",
+  int = "int",
+  bigInt = "bigint",
+  float = "float",
+  double = "double",
+  decimal = "decimal",
+  year = "year",
+  date = "date",
+  time = "time",
+  dateTime = "datetime",
+  timestamp = "timestamp",
+  boolean = "boolean"
+}
+type DBType = "char" | "varchar" | "text" | "tinyint" | "smallint" | "mediumint" | "int" | "bigint" | "float" | "double" | "decimal" | "year" | "date" | "time" | "datetime" | "timestamp" | "boolean";
+type DBStringTypes = DBColumnTypes.char | DBColumnTypes.varchar;
+type DBTextTypes = DBColumnTypes.text;
+type DBIntegerTypes = DBColumnTypes.tinyInt | DBColumnTypes.smallInt | DBColumnTypes.mediumInt | DBColumnTypes.int | DBColumnTypes.bigInt;
+type DBFloatingTypes = DBColumnTypes.float | DBColumnTypes.double;
+type DBDateTypes = DBColumnTypes.time | DBColumnTypes.date | DBColumnTypes.year;
+//#endregion
+//#region src/generatorv2/nodes/ConditionValues.d.ts
 type ContextConditionValue = {
-    kind: 'context';
-    field: string;
-    onNotDefined: OnNotDefinedAction;
+  kind: "context";
+  field: string;
+  onNotDefined: OnNotDefinedAction;
 };
 type FixedConditionValue = {
-    kind: 'fixed';
-    value: string | number;
+  kind: "fixed";
+  value: string | number;
 };
 type TodayStartConditionValue = {
-    kind: 'today';
-    type: 'date' | 'datetime';
-    thresholdHour?: number;
+  kind: "today";
+  type: "date" | "datetime";
+  thresholdHour?: number;
 };
 type NowConditionValue = {
-    kind: 'now';
+  kind: "now";
 };
 type OnNotDefinedAction = {
-    action: 'error';
-    message: string;
+  action: "error";
+  message: string;
 } | {
-    action: 'defaultValue';
-    value: string | number;
+  action: "defaultValue";
+  value: string | number;
 };
 type ConditionValue = ContextConditionValue | FixedConditionValue | TodayStartConditionValue | NowConditionValue;
-
-type QueryConditionValue = ConditionValue | FieldQueryConditionValue | ArgQueryConditionValue;
-type FieldQueryConditionValue = {
-    kind: 'field';
-    column: string;
-};
-type ArgQueryConditionValue = {
-    kind: 'arg';
-    name: string;
-    type: 'Int' | 'Float' | 'String' | string;
+//#endregion
+//#region src/generatorv2/nodes/JoinConditionNode.d.ts
+type JoinConditionValue = {
+  kind: "parent" | "child";
+  field: string;
+} | ConditionValue;
+type JoinConditionRangeValue = {
+  kind: "range";
+  begin: JoinConditionValue;
+  end: JoinConditionValue;
+} | DateRangeConditionValue;
+type DateRangeConditionValue = {
+  kind: "date-range";
+  range: "today";
+  thresholdHour?: number;
 };
-type QueryConditionNode = {
-    kind: 'comparison';
-    left: QueryConditionValue;
-    operator: ComparisonOperators;
-    right: QueryConditionValue;
+type JoinConditionNode = {
+  kind: "comparison";
+  left: JoinConditionValue;
+  operator: ComparisonOperators;
+  right: JoinConditionValue;
+} | {
+  kind: "comparison";
+  left: JoinConditionValue;
+  operator: "BETWEEN";
+  right: JoinConditionRangeValue;
 } | {
-    kind: 'between';
-    left: QueryConditionValue;
-    operator: 'BETWEEN';
-    begin: QueryConditionValue;
-    end: QueryConditionValue;
+  kind: "comparison";
+  left: JoinConditionValue;
+  operator: "IN";
+  right: JoinConditionValue[];
+} | {
+  kind: "isNull";
+  value: JoinConditionValue;
+  not: boolean;
+} | JoinCustomConditionNode;
+type JoinCustomConditionNode = {
+  kind: "custom";
+  conditionName: string;
+  parentRequiredFields?: string[];
+  childRequiredFields?: string[];
 };
-
-declare enum DBColumnTypes {
-    char = "char",
-    varchar = "varchar",
-    text = "text",
-    tinyInt = "tinyint",
-    smallInt = "smallint",
-    mediumInt = "mediumint",
-    int = "int",
-    bigInt = "bigint",
-    float = "float",
-    double = "double",
-    decimal = "decimal",
-    year = "year",
-    date = "date",
-    time = "time",
-    dateTime = "datetime",
-    timestamp = "timestamp",
-    boolean = "boolean"
-}
-type DBType = 'char' | 'varchar' | 'text' | 'tinyint' | 'smallint' | 'mediumint' | 'int' | 'bigint' | 'float' | 'double' | 'decimal' | 'year' | 'date' | 'time' | 'datetime' | 'timestamp' | 'boolean';
-type DBStringTypes = DBColumnTypes.char | DBColumnTypes.varchar;
-type DBTextTypes = DBColumnTypes.text;
-type DBIntegerTypes = DBColumnTypes.tinyInt | DBColumnTypes.smallInt | DBColumnTypes.mediumInt | DBColumnTypes.int | DBColumnTypes.bigInt;
-type DBFloatingTypes = DBColumnTypes.float | DBColumnTypes.double;
-type DBNumberTypes = DBIntegerTypes | DBFloatingTypes | DBColumnTypes.decimal;
-type DBDateTypes = DBColumnTypes.time | DBColumnTypes.date | DBColumnTypes.year;
-
-interface Serializable<T> {
-    serialize(): T;
-}
-
-type ForeignKeyReferentialAction = 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION';
-
-type Relation = 'One' | 'OneOrZero' | 'Many';
-
+//#endregion
+//#region src/migration/data/virtualRelation.d.ts
+type VirtualRelation = {
+  parentTable: string;
+  childTable: string;
+  parentFieldName?: string;
+  childFieldName?: string;
+  conditions: JoinConditionNode[];
+  parentType?: "array" | "nullable" | "notnull";
+  childType?: "array" | "nullable" | "notnull";
+};
+//#endregion
+//#region src/generatorv2/scripts/gqlTypes.d.ts
+type GQLPrimitive = "Int" | "Float" | "String" | "Boolean" | "ID";
+//#endregion
+//#region src/migration/data/foreignKey.d.ts
+type ForeignKeyReferentialAction = "RESTRICT" | "CASCADE" | "SET NULL" | "NO ACTION";
+//#endregion
+//#region src/migration/serialized/serializedColumn.d.ts
 type ColumnOptions = {
-    updatable: boolean;
-    autoIncrementHashId: boolean;
-    hashSalt?: string;
+  updatable: boolean;
+  autoIncrementHashId: boolean;
+  hashSalt?: string;
 };
 interface SerializedColumnBase {
-    hasReference: boolean;
-    fieldName: string;
-    columnName: string;
-    type: DBColumnTypes;
-    notNull: boolean;
-    default: SqlValueType | undefined;
-    zerofill: boolean;
-    signed: boolean | undefined;
-    autoIncrement: boolean;
-    length: number | undefined;
-    scale: number | undefined;
-    defaultCurrentTimeStamp: boolean;
-    onUpdateCurrentTimeStamp: boolean;
-    option: ColumnOptions;
+  hasReference: boolean;
+  fieldName: string;
+  columnName: string;
+  type: DBColumnTypes;
+  notNull: boolean;
+  default: SqlValueType | undefined;
+  zerofill: boolean;
+  signed: boolean | undefined;
+  autoIncrement: boolean;
+  length: number | undefined;
+  scale: number | undefined;
+  defaultCurrentTimeStamp: boolean;
+  onUpdateCurrentTimeStamp: boolean;
+  option: ColumnOptions;
 }
 interface SerializedNormalColumn extends SerializedColumnBase {
-    hasReference: false;
+  hasReference: false;
 }
 interface Reference {
-    parentTable: string;
-    parentColumn: string;
-    columnName: string;
-    relation: Relation;
-    parentFieldName?: string;
-    fieldName?: string;
-    relationName?: string;
-    onUpdate?: ForeignKeyReferentialAction;
-    onDelete?: ForeignKeyReferentialAction;
-    noFKey?: boolean;
+  parentTable: string;
+  parentColumn: string;
+  columnName: string;
+  relation: Relation;
+  parentFieldName?: string;
+  fieldName?: string;
+  relationName?: string;
+  onUpdate?: ForeignKeyReferentialAction;
+  onDelete?: ForeignKeyReferentialAction;
+  noFKey?: boolean;
 }
 interface SerializedReferenceColumn extends SerializedColumnBase {
-    hasReference: true;
-    reference: Reference;
+  hasReference: true;
+  reference: Reference;
 }
 type SerializedColumn = SerializedNormalColumn | SerializedReferenceColumn;
-
+//#endregion
+//#region src/migration/serializable/serializable.d.ts
+interface Serializable<T> {
+  serialize(): T;
+}
+//#endregion
+//#region src/generatorv2/nodes/entityName.d.ts
+declare class EntityName {
+  readonly name: string;
+  static fromTableName(tableName: string): EntityName;
+  constructor(name: string);
+  toString(): string;
+  creatableInterface(): string;
+  updatable(): string;
+  identifiableInterfaceName(): string;
+  relationTypeName(): string;
+  entityWithRelationTypeName(): string;
+  resultType(): string;
+  fieldsTypeName(): string;
+  dataSourceName(): string;
+  generatedDataSourceName(): string;
+  lowerCase(): string;
+  createInputName(): string;
+  updateInputName(): string;
+  identifyInputName(): string;
+  IDEncoderName(): string;
+}
+//#endregion
+//#region src/migration/data/index.d.ts
 interface Index {
-    constraintName: string;
-    columns: string[];
+  constraintName: string;
+  columns: string[];
 }
 declare class DBIndex implements Index, Serializable<Index> {
-    readonly tableName: string;
-    readonly columns: string[];
-    readonly constraintName: string;
-    constructor(tableName: string, columns: string[]);
-    private toConstraintName;
-    addSql(): string;
-    dropSql(): string;
-    serialize(): Index;
+  readonly tableName: string;
+  readonly columns: string[];
+  readonly constraintName: string;
+  constructor(tableName: string, columns: string[]);
+  private toConstraintName;
+  addSql(): string;
+  dropSql(): string;
+  serialize(): Index;
 }
-
-type JoinConditionValue = {
-    kind: 'parent' | 'child';
-    field: string;
-} | ConditionValue;
-type JoinConditionRangeValue = {
-    kind: 'range';
-    begin: JoinConditionValue;
-    end: JoinConditionValue;
-} | DateRangeConditionValue;
-type DateRangeConditionValue = {
-    kind: 'date-range';
-    range: 'today';
-    thresholdHour?: number;
-};
-type JoinConditionNode = {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: ComparisonOperators;
-    right: JoinConditionValue;
-} | {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: 'BETWEEN';
-    right: JoinConditionRangeValue;
-} | {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: 'IN';
-    right: JoinConditionValue[];
-} | {
-    kind: 'isNull';
-    value: JoinConditionValue;
-    not: boolean;
-} | JoinCustomConditionNode;
-type JoinCustomConditionNode = {
-    kind: 'custom';
-    conditionName: string;
-    parentRequiredFields?: string[];
-    childRequiredFields?: string[];
-};
-
-type VirtualRelation = {
-    parentTable: string;
-    childTable: string;
-    parentFieldName?: string;
-    childFieldName?: string;
-    conditions: JoinConditionNode[];
-    parentType?: 'array' | 'nullable' | 'notnull';
-    childType?: 'array' | 'nullable' | 'notnull';
-};
-
+//#endregion
+//#region src/migration/serialized/serializedStore.d.ts
 interface SerializedTable {
-    columns: SerializedColumn[];
-    primaryKey: string[];
-    uniqueKeys: string[][];
-    indexes: Index[];
-    tableName: string;
-    gqlOption: GQLOption;
-    virtualRelations: VirtualRelation[];
+  columns: SerializedColumn[];
+  primaryKey: string[];
+  uniqueKeys: string[][];
+  indexes: Index[];
+  tableName: string;
+  gqlOption: GQLOption;
+  virtualRelations: VirtualRelation[];
 }
-
-type GQLPrimitive = 'Int' | 'Float' | 'String' | 'Boolean' | 'ID';
-
+//#endregion
+//#region src/migration/serializable/table.d.ts
+interface Table extends Serializable<SerializedTable> {
+  column(columnName: string): BaseColumn;
+  tableName: string;
+  gqlOption: GQLOption;
+  primaryKey: string[];
+}
+declare class TableHandler implements Table {
+  store: DataStore;
+  private indexes;
+  get index(): DBIndex[];
+  private _columns;
+  get columns(): BaseColumn[];
+  private readonly _virtualRelations;
+  get virtualRelations(): VirtualRelation[];
+  addVirtualRelation(relation: Omit<VirtualRelation, "childTable">): void;
+  primaryKey: string[];
+  readonly uniqueKeys: string[][];
+  readonly tableName: string;
+  private _gqlOption;
+  get gqlOption(): GQLOption;
+  constructor(table: Partial<SerializedTable> & Pick<SerializedTable, "tableName">, store: DataStore);
+  column(columnName: string): BaseColumn;
+  addColumn(column: BaseColumn, isPrimary?: boolean, isUnique?: boolean): void;
+  dropColumn(columnName: string): void;
+  serialize(): SerializedTable;
+  addReferences(ref: Reference, fieldName?: string, notNull?: boolean): this;
+  private getIndexConstraintName;
+  addIndex(...columns: string[]): this;
+  removeIndex(...columns: string[]): this;
+  addUniqueKey(...columnNames: string[]): this;
+  setPrimaryKey(...columnNames: string[]): this;
+  showCreateTable(): string;
+  hasColumn(columnName: string): boolean;
+  isColumnPrimary(columnName: string): boolean;
+  getEntityName(): EntityName;
+  setGQLOption(option: Partial<GQLOption>): void;
+  getReferenceColumns(): ReferenceColumn[];
+  addForeignKey(reference: Reference): void;
+  changeType(columnName: string, type: DBColumnTypes): void;
+  setDefault(columnName: string, value: string | number | null): void;
+  protected updateColumn(columnName: string, diff: Partial<SerializedColumn>): void;
+  getPrimaryKeyColumns(): BaseColumn[];
+}
+//#endregion
+//#region src/migration/serializable/column.d.ts
 interface Column extends Serializable<SerializedColumn> {
-    fieldName(): string;
-    columnName(): string;
-    dataType(): DBColumnTypes;
-    toSql(): string;
-    isReference(): this is ReferenceColumn;
-    isNullable(): boolean;
-    tsType(): string;
-    gqlType(): GQLPrimitive;
-    isNullableOnCreate(): boolean;
+  fieldName(): string;
+  columnName(): string;
+  dataType(): DBColumnTypes;
+  toSql(): string;
+  isReference(): this is ReferenceColumn;
+  isNullable(): boolean;
+  tsType(): string;
+  gqlType(): GQLPrimitive;
+  isNullableOnCreate(): boolean;
 }
 declare class BaseColumn implements Column {
-    data: SerializedColumn;
-    table: Table;
-    constructor(data: SerializedColumn, table: Table);
-    fieldName(): string;
-    columnName(): string;
-    dataType(): DBColumnTypes;
-    tsType(): string;
-    gqlType(): GQLPrimitive;
-    isNullable(): boolean;
-    isNullableOnCreate(): boolean;
-    isReference(): this is ReferenceColumn;
-    serialize(): SerializedColumn;
-    toSql(): string;
-    isPrimary(): boolean;
-    isUpdatable(): boolean;
+  data: SerializedColumn;
+  table: Table;
+  constructor(data: SerializedColumn, table: Table);
+  fieldName(): string;
+  columnName(): string;
+  dataType(): DBColumnTypes;
+  tsType(): string;
+  gqlType(): GQLPrimitive;
+  isNullable(): boolean;
+  isNullableOnCreate(): boolean;
+  isReference(): this is ReferenceColumn;
+  serialize(): SerializedColumn;
+  toSql(): string;
+  isPrimary(): boolean;
+  isUpdatable(): boolean;
 }
 declare class ReferenceColumn extends BaseColumn {
-    data: SerializedReferenceColumn;
-    constructor(data: SerializedReferenceColumn, table: Table);
-    getConstraintName(): string;
-}
-
-declare class EntityName {
-    readonly name: string;
-    static fromTableName(tableName: string): EntityName;
-    constructor(name: string);
-    toString(): string;
-    creatableInterface(): string;
-    updatable(): string;
-    identifiableInterfaceName(): string;
-    relationTypeName(): string;
-    entityWithRelationTypeName(): string;
-    resultType(): string;
-    fieldsTypeName(): string;
-    dataSourceName(): string;
-    generatedDataSourceName(): string;
-    lowerCase(): string;
-    createInputName(): string;
-    updateInputName(): string;
-    identifyInputName(): string;
-    IDEncoderName(): string;
-}
-
-interface Table extends Serializable<SerializedTable> {
-    column(columnName: string): BaseColumn;
-    tableName: string;
-    gqlOption: GQLOption;
-    primaryKey: string[];
+  data: SerializedReferenceColumn;
+  constructor(data: SerializedReferenceColumn, table: Table);
+  getConstraintName(): string;
 }
-declare class TableHandler implements Table {
-    store: DataStore;
-    private indexes;
-    get index(): DBIndex[];
-    private _columns;
-    get columns(): BaseColumn[];
-    private readonly _virtualRelations;
-    get virtualRelations(): VirtualRelation[];
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): void;
-    primaryKey: string[];
-    readonly uniqueKeys: string[][];
-    readonly tableName: string;
-    private _gqlOption;
-    get gqlOption(): GQLOption;
-    constructor(table: Partial<SerializedTable> & Pick<SerializedTable, 'tableName'>, store: DataStore);
-    column(columnName: string): BaseColumn;
-    addColumn(column: BaseColumn, isPrimary?: boolean, isUnique?: boolean): void;
-    dropColumn(columnName: string): void;
-    serialize(): SerializedTable;
-    addReferences(ref: Reference, fieldName?: string, notNull?: boolean): this;
-    private getIndexConstraintName;
-    addIndex(...columns: string[]): this;
-    removeIndex(...columns: string[]): this;
-    addUniqueKey(...columnNames: string[]): this;
-    setPrimaryKey(...columnNames: string[]): this;
-    showCreateTable(): string;
-    hasColumn(columnName: string): boolean;
-    isColumnPrimary(columnName: string): boolean;
-    getEntityName(): EntityName;
-    setGQLOption(option: Partial<GQLOption>): void;
-    getReferenceColumns(): ReferenceColumn[];
-    addForeignKey(reference: Reference): void;
-    changeType(columnName: string, type: DBColumnTypes): void;
-    setDefault(columnName: string, value: string | number | null): void;
-    protected updateColumn(columnName: string, diff: Partial<SerializedColumn>): void;
-    getPrimaryKeyColumns(): BaseColumn[];
-}
-
+//#endregion
+//#region src/migration/dataStore.d.ts
 interface DataStore {
-    table(tableName: string): Table;
+  table(tableName: string): Table;
 }
-
+//#endregion
+//#region src/generatorv2/nodes/QueryConditionNode.d.ts
+type QueryConditionValue = ConditionValue | FieldQueryConditionValue | ArgQueryConditionValue;
+type FieldQueryConditionValue = {
+  kind: "field";
+  column: string;
+};
+type ArgQueryConditionValue = {
+  kind: "arg";
+  name: string;
+  type: "Int" | "Float" | "String" | string;
+};
+type QueryConditionNode = {
+  kind: "comparison";
+  left: QueryConditionValue;
+  operator: ComparisonOperators;
+  right: QueryConditionValue;
+} | {
+  kind: "between";
+  left: QueryConditionValue;
+  operator: "BETWEEN";
+  begin: QueryConditionValue;
+  end: QueryConditionValue;
+};
+//#endregion
+//#region src/migration/data/GQLOption.d.ts
 interface GqlFromContextParam {
-    column: string;
-    contextName?: string;
+  column: string;
+  contextName?: string;
 }
 type GQLMutation = {
-    type: 'create' | 'update' | 'delete';
-    noReFetch: boolean;
-    middlewares: string[];
-    contextFields: GqlFromContextParam[];
-    subscription: {
-        enabled: boolean;
-        subscriptionFilter: string[];
-    };
+  type: "create" | "update" | "delete";
+  noReFetch: boolean;
+  middlewares: string[];
+  contextFields: GqlFromContextParam[];
+  subscription: {
+    enabled: boolean;
+    subscriptionFilter: string[];
+  };
 };
 type GQLQuery = {
-    type: 'single' | 'list-all' | 'list-paging';
-    name: string;
-    conditions: QueryConditionNode[];
-    middlewares: string[];
+  type: "single" | "list-all" | "list-paging";
+  name: string;
+  conditions: QueryConditionNode[];
+  middlewares: string[];
 } | {
-    type: 'primary';
-    name?: never;
-    conditions: never[];
-    middlewares: string[];
+  type: "primary";
+  name?: never;
+  conditions: never[];
+  middlewares: string[];
 };
 interface GQLOption {
-    enabled: boolean;
-    queries: GQLQuery[];
-    mutations: GQLMutation[];
+  enabled: boolean;
+  queries: GQLQuery[];
+  mutations: GQLMutation[];
 }
-
-declare const Queries: {
-    single: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    listAll: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    paging: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    primary: (middlewares?: string[]) => GQLQuery;
-};
-
-type Option = {
-    noRefetch?: boolean;
-    middlewares?: string[];
-    contextFields?: GqlFromContextParam[];
-    subscription?: {
-        enabled: boolean;
-        subscriptionFilter?: string[];
-    } | boolean;
-};
-declare const Mutations: {
-    create: (options?: Option) => GQLMutation;
-    update: (options?: Option) => GQLMutation;
-    delete: (options?: Omit<Option, 'noRefetch'>) => GQLMutation;
-};
-
-declare const Conditions: {
-    readonly betweenRel: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
-    readonly betweenQuery: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
-    readonly custom: (conditionName: string, parentRequiredFields?: string[], childRequiredFields?: string[]) => JoinConditionNode;
-    readonly rel: {
-        readonly between: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
-        readonly comparison: (left: JoinConditionValue, operator: ComparisonOperators, right: JoinConditionValue) => JoinConditionNode;
-        readonly in: (left: JoinConditionValue, right: JoinConditionValue[]) => JoinConditionNode;
-        readonly isNull: (value: JoinConditionValue) => JoinConditionNode;
-        readonly isNotNull: (value: JoinConditionValue) => JoinConditionNode;
-    };
-    readonly query: {
-        readonly between: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
-        readonly comparison: (left: QueryConditionValue, operator: ComparisonOperators, right: QueryConditionValue) => QueryConditionNode;
-    };
-    readonly value: {
-        readonly parent: (field: string) => JoinConditionValue;
-        readonly child: (field: string) => JoinConditionValue;
-        readonly contextOrError: (field: string, errorMessage: string) => ConditionValue;
-        readonly contextOrDefault: (field: string, defaultValue: string | number) => ConditionValue;
-        readonly fixed: (value: string | number) => ConditionValue;
-        readonly today: (thresholdHour?: number, date?: boolean) => ConditionValue;
-        readonly now: () => ConditionValue;
-        readonly field: (column: string) => QueryConditionValue;
-        readonly arg: (name: string, type: 'Int' | 'Float' | 'String') => QueryConditionValue;
-    };
-    readonly range: {
-        readonly values: (begin: JoinConditionValue, end: JoinConditionValue) => JoinConditionRangeValue;
-        readonly today: (thresholdHour?: number) => JoinConditionRangeValue;
-    };
-};
-
+//#endregion
+//#region src/migration/creators/columnBuilder.d.ts
 declare abstract class ColumnBuilderBase {
-    readonly columnName: string;
-    protected _primary: boolean;
-    protected _notNull: boolean;
-    protected _unique: boolean;
-    protected _option: ColumnOptions;
-    protected _fieldName: string;
-    protected constructor(columnName: string);
-    fieldName(fieldName: string): this;
-    notNull(): this;
-    nullable(): this;
-    primary(): this;
-    unique(): this;
-    updatable(updatable: boolean): this;
-    abstract build(): {
-        data: SerializedColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
+  readonly columnName: string;
+  protected _primary: boolean;
+  protected _notNull: boolean;
+  protected _unique: boolean;
+  protected _option: ColumnOptions;
+  protected _fieldName: string;
+  protected constructor(columnName: string);
+  fieldName(fieldName: string): this;
+  notNull(): this;
+  nullable(): this;
+  primary(): this;
+  unique(): this;
+  updatable(updatable: boolean): this;
+  abstract build(): {
+    data: SerializedColumn;
+    isPrimary: boolean;
+    isUnique: boolean;
+  };
 }
 declare abstract class ColumnBuilder extends ColumnBuilderBase {
-    protected type: DBColumnTypes;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    protected _zerofill: boolean;
-    protected _signed: boolean | undefined;
-    protected _autoIncrement: boolean;
-    protected _default: SqlValueType | undefined;
-    protected _defaultCurrentTimeStamp: boolean;
-    protected _onUpdateCurrentTimeStamp: boolean;
-    protected constructor(name: string, type: DBColumnTypes, length?: number | undefined, scale?: number | undefined);
-    default(value: SqlValueType | undefined): this;
-    build(): {
-        data: SerializedNormalColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
+  protected type: DBColumnTypes;
+  protected length?: number | undefined;
+  protected scale?: number | undefined;
+  protected _zerofill: boolean;
+  protected _signed: boolean | undefined;
+  protected _autoIncrement: boolean;
+  protected _default: SqlValueType | undefined;
+  protected _defaultCurrentTimeStamp: boolean;
+  protected _onUpdateCurrentTimeStamp: boolean;
+  protected constructor(name: string, type: DBColumnTypes, length?: number | undefined, scale?: number | undefined);
+  default(value: SqlValueType | undefined): this;
+  build(): {
+    data: SerializedNormalColumn;
+    isPrimary: boolean;
+    isUnique: boolean;
+  };
 }
 declare class StringColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBStringTypes;
-    protected length?: number | undefined;
-    constructor(name: string, type: DBStringTypes, length?: number | undefined);
-    default(value: string | null | undefined): this;
+  readonly name: string;
+  protected type: DBStringTypes;
+  protected length?: number | undefined;
+  constructor(name: string, type: DBStringTypes, length?: number | undefined);
+  default(value: string | null | undefined): this;
 }
 declare class TextColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBTextTypes;
-    constructor(name: string, type: DBTextTypes);
-    default(value: string | null | undefined): this;
+  readonly name: string;
+  protected type: DBTextTypes;
+  constructor(name: string, type: DBTextTypes);
+  default(value: string | null | undefined): this;
 }
 declare class NumberColumnBuilder extends ColumnBuilder {
-    constructor(name: string, type: DBNumberTypes, length?: number, scale?: number);
-    signed(): this;
-    unsigned(): this;
-    zerofill(): this;
-    default(value: number | null | undefined): this;
+  signed(): this;
+  unsigned(): this;
+  zerofill(): this;
+  default(value: number | null | undefined): this;
 }
 declare class IntegerColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBIntegerTypes;
-    protected length?: number | undefined;
-    constructor(name: string, type: DBIntegerTypes, length?: number | undefined);
-    autoIncrement(): this;
+  readonly name: string;
+  protected type: DBIntegerTypes;
+  protected length?: number | undefined;
+  constructor(name: string, type: DBIntegerTypes, length?: number | undefined);
+  autoIncrement(): this;
 }
 declare class FloatColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBFloatingTypes;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    constructor(name: string, type: DBFloatingTypes, length?: number | undefined, scale?: number | undefined);
-    autoIncrement(): this;
+  readonly name: string;
+  protected type: DBFloatingTypes;
+  protected length?: number | undefined;
+  protected scale?: number | undefined;
+  constructor(name: string, type: DBFloatingTypes, length?: number | undefined, scale?: number | undefined);
+  autoIncrement(): this;
 }
 declare class DecimalColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBColumnTypes.decimal;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    constructor(name: string, type: DBColumnTypes.decimal, length?: number | undefined, scale?: number | undefined);
+  readonly name: string;
+  protected type: DBColumnTypes.decimal;
+  protected length?: number | undefined;
+  protected scale?: number | undefined;
+  constructor(name: string, type: DBColumnTypes.decimal, length?: number | undefined, scale?: number | undefined);
 }
 declare class DateColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBDateTypes;
-    constructor(name: string, type: DBDateTypes);
-    default(value: string | number | null | undefined): this;
+  readonly name: string;
+  protected type: DBDateTypes;
+  constructor(name: string, type: DBDateTypes);
+  default(value: string | number | null | undefined): this;
 }
 declare class TimeStampColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBColumnTypes.timestamp | DBColumnTypes.dateTime;
-    constructor(name: string, type: DBColumnTypes.timestamp | DBColumnTypes.dateTime);
-    default(value: 'CURRENT_TIMESTAMP' | string | null | undefined): this;
-    defaultCurrentTimeStamp(): this;
-    onUpdateCurrentTimeStamp(): this;
+  readonly name: string;
+  protected type: DBColumnTypes.timestamp | DBColumnTypes.dateTime;
+  constructor(name: string, type: DBColumnTypes.timestamp | DBColumnTypes.dateTime);
+  default(value: "CURRENT_TIMESTAMP" | string | null | undefined): this;
+  defaultCurrentTimeStamp(): this;
+  onUpdateCurrentTimeStamp(): this;
 }
 declare class ReferenceColumnBuilder extends ColumnBuilderBase {
-    protected readonly ref: Reference;
-    protected readonly parent: Column;
-    constructor(ref: Reference, parent: Column);
-    notNull(): this;
-    nullable(): this;
-    primary(): this;
-    unique(): this;
-    build(): {
-        data: SerializedReferenceColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
-}
-
-type CreateColumn = {
-    char: (length: number) => StringColumnBuilder;
-    varchar: (length: number) => StringColumnBuilder;
-    text: () => TextColumnBuilder;
-    tinyInt: (length?: number) => IntegerColumnBuilder;
-    smallInt: (length?: number) => IntegerColumnBuilder;
-    mediumInt: (length?: number) => IntegerColumnBuilder;
-    int: (length?: number) => IntegerColumnBuilder;
-    bigInt: (length?: number) => IntegerColumnBuilder;
-    float: (length?: number, scale?: number) => FloatColumnBuilder;
-    double: (length?: number, scale?: number) => FloatColumnBuilder;
-    decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
-    year: () => DateColumnBuilder;
-    date: () => DateColumnBuilder;
-    time: () => DateColumnBuilder;
-    dateTime: () => TimeStampColumnBuilder;
-    timestamp: () => TimeStampColumnBuilder;
-};
-
-interface MigrationTable extends Table {
-    addIndex(...columns: string[]): MigrationTable;
-    removeIndex(...columns: string[]): MigrationTable;
-    addColumn(name: string, create: (column: CreateColumn) => ColumnBuilder): MigrationTable;
-    _addColumn(column: SerializedColumn): MigrationTable;
-    dropColumn(columnName: string): MigrationTable;
-    addForeignKey(reference: Reference): MigrationTable;
-    changeColumnType(columnName: string, type: DBType): MigrationTable;
-    setDefault(columnName: string, value: string | number | null): MigrationTable;
-    enableGQL(): MigrationTable;
-    setGQLOption(option: GQLOption): MigrationTable;
-    addGQLQuery(...queries: GQLQuery[]): MigrationTable;
-    addGQLMutation(...mutations: GQLMutation[]): MigrationTable;
+  protected readonly ref: Reference;
+  protected readonly parent: Column;
+  constructor(ref: Reference, parent: Column);
+  notNull(): this;
+  nullable(): this;
+  primary(): this;
+  unique(): this;
+  build(): {
+    data: SerializedReferenceColumn;
+    isPrimary: boolean;
+    isUnique: boolean;
+  };
 }
-
+//#endregion
+//#region src/migration/creators/columnCreator.d.ts
 declare class ColumnCreator {
-    private table;
-    private name;
-    constructor(table: TableCreator, name: string);
-    char: (length: number) => StringColumnBuilder;
-    varchar: (length: number) => StringColumnBuilder;
-    text: () => TextColumnBuilder;
-    tinyInt: (length?: number) => IntegerColumnBuilder;
-    smallInt: (length?: number) => IntegerColumnBuilder;
-    mediumInt: (length?: number) => IntegerColumnBuilder;
-    int: (length?: number) => IntegerColumnBuilder;
-    bigInt: (length?: number) => IntegerColumnBuilder;
-    float: (length?: number, scale?: number) => FloatColumnBuilder;
-    double: (length?: number, scale?: number) => FloatColumnBuilder;
-    decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
-    year: () => DateColumnBuilder;
-    date: () => DateColumnBuilder;
-    time: () => DateColumnBuilder;
-    dateTime: () => TimeStampColumnBuilder;
-    timestamp: () => TimeStampColumnBuilder;
-    private create;
+  private table;
+  private name;
+  constructor(table: TableCreator, name: string);
+  char: (length: number) => StringColumnBuilder;
+  varchar: (length: number) => StringColumnBuilder;
+  text: () => TextColumnBuilder;
+  tinyInt: (length?: number) => IntegerColumnBuilder;
+  smallInt: (length?: number) => IntegerColumnBuilder;
+  mediumInt: (length?: number) => IntegerColumnBuilder;
+  int: (length?: number) => IntegerColumnBuilder;
+  bigInt: (length?: number) => IntegerColumnBuilder;
+  float: (length?: number, scale?: number) => FloatColumnBuilder;
+  double: (length?: number, scale?: number) => FloatColumnBuilder;
+  decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
+  year: () => DateColumnBuilder;
+  date: () => DateColumnBuilder;
+  time: () => DateColumnBuilder;
+  dateTime: () => TimeStampColumnBuilder;
+  timestamp: () => TimeStampColumnBuilder;
+  private create;
 }
-
+//#endregion
+//#region src/migration/creators/tableCreator.d.ts
 interface TableBuilder {
-    autoIncrementHashId(columnName: string, option?: {
-        salt?: string;
-        bigint?: boolean;
-    }): TableBuilder;
-    column(columnName: string): ColumnCreator;
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): TableBuilder;
-    references(reference: Reference, notNull?: boolean): ColumnBuilderBase;
-    setPrimaryKey(...columnNames: string[]): TableBuilder;
-    addUniqueKey(...columnNames: string[]): TableBuilder;
-    createdAt(): TableBuilder;
-    updatedAt(): TableBuilder;
-    addIndex(...columns: string[]): TableBuilder;
-    enableGQL(): TableBuilder;
-    setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    addGQLQuery(...query: GQLQuery[]): TableBuilder;
-    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
+  autoIncrementHashId(columnName: string, option?: {
+    salt?: string;
+    bigint?: boolean;
+  }): TableBuilder;
+  column(columnName: string): ColumnCreator;
+  addVirtualRelation(relation: Omit<VirtualRelation, "childTable">): TableBuilder;
+  references(reference: Reference, notNull?: boolean): ColumnBuilderBase;
+  setPrimaryKey(...columnNames: string[]): TableBuilder;
+  addUniqueKey(...columnNames: string[]): TableBuilder;
+  createdAt(): TableBuilder;
+  updatedAt(): TableBuilder;
+  addIndex(...columns: string[]): TableBuilder;
+  enableGQL(): TableBuilder;
+  setGQLOption(option: Partial<GQLOption>): TableBuilder;
+  addGQLQuery(...query: GQLQuery[]): TableBuilder;
+  addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
 }
 declare class TableCreator implements TableBuilder {
-    tableName: string;
-    protected readonly store: DataStore;
-    private readonly table;
-    private readonly columns;
-    constructor(tableName: string, store: DataStore);
-    autoIncrementHashId(columnName: string, option?: {
-        salt?: string;
-        bigint?: boolean;
-    }): TableBuilder;
-    column(name: string): ColumnCreator;
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): this;
-    addColumn(column: ColumnBuilderBase): void;
-    addUniqueKey(...columnNames: string[]): TableBuilder;
-    references(ref: Reference): ReferenceColumnBuilder;
-    setPrimaryKey(...columnNames: string[]): TableBuilder;
-    create(): TableHandler;
-    createdAt(): TableBuilder;
-    updatedAt(): TableBuilder;
-    addIndex(...columns: string[]): TableBuilder;
-    enableGQL(): TableBuilder;
-    setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    addGQLQuery(...query: GQLQuery[]): TableBuilder;
-    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
+  tableName: string;
+  protected readonly store: DataStore;
+  private readonly table;
+  private readonly columns;
+  constructor(tableName: string, store: DataStore);
+  autoIncrementHashId(columnName: string, option?: {
+    salt?: string;
+    bigint?: boolean;
+  }): TableBuilder;
+  column(name: string): ColumnCreator;
+  addVirtualRelation(relation: Omit<VirtualRelation, "childTable">): this;
+  addColumn(column: ColumnBuilderBase): void;
+  addUniqueKey(...columnNames: string[]): TableBuilder;
+  references(ref: Reference): ReferenceColumnBuilder;
+  setPrimaryKey(...columnNames: string[]): TableBuilder;
+  create(): TableHandler;
+  createdAt(): TableBuilder;
+  updatedAt(): TableBuilder;
+  addIndex(...columns: string[]): TableBuilder;
+  enableGQL(): TableBuilder;
+  setGQLOption(option: Partial<GQLOption>): TableBuilder;
+  addGQLQuery(...query: GQLQuery[]): TableBuilder;
+  addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
 }
-
+//#endregion
+//#region src/migration/creators/createColumn.d.ts
+type CreateColumn = {
+  char: (length: number) => StringColumnBuilder;
+  varchar: (length: number) => StringColumnBuilder;
+  text: () => TextColumnBuilder;
+  tinyInt: (length?: number) => IntegerColumnBuilder;
+  smallInt: (length?: number) => IntegerColumnBuilder;
+  mediumInt: (length?: number) => IntegerColumnBuilder;
+  int: (length?: number) => IntegerColumnBuilder;
+  bigInt: (length?: number) => IntegerColumnBuilder;
+  float: (length?: number, scale?: number) => FloatColumnBuilder;
+  double: (length?: number, scale?: number) => FloatColumnBuilder;
+  decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
+  year: () => DateColumnBuilder;
+  date: () => DateColumnBuilder;
+  time: () => DateColumnBuilder;
+  dateTime: () => TimeStampColumnBuilder;
+  timestamp: () => TimeStampColumnBuilder;
+};
+//#endregion
+//#region src/migration/front/tableMigrator.d.ts
+interface MigrationTable extends Table {
+  addIndex(...columns: string[]): MigrationTable;
+  removeIndex(...columns: string[]): MigrationTable;
+  addColumn(name: string, create: (column: CreateColumn) => ColumnBuilder): MigrationTable;
+  _addColumn(column: SerializedColumn): MigrationTable;
+  dropColumn(columnName: string): MigrationTable;
+  addForeignKey(reference: Reference): MigrationTable;
+  changeColumnType(columnName: string, type: DBType): MigrationTable;
+  setDefault(columnName: string, value: string | number | null): MigrationTable;
+  enableGQL(): MigrationTable;
+  setGQLOption(option: GQLOption): MigrationTable;
+  addGQLQuery(...queries: GQLQuery[]): MigrationTable;
+  addGQLMutation(...mutations: GQLMutation[]): MigrationTable;
+}
+//#endregion
+//#region src/migration/front/storeMigrator.d.ts
 interface MigrationStore extends DataStore {
-    createTable(tableName: string, tableCreator: (table: TableBuilder) => void): MigrationStore;
-    dropTable(tableName: string): MigrationStore;
-    table(tableName: string): MigrationTable;
-    sql(...sql: string[]): MigrationStore;
-    setConfig(config: NestedPartial$1<SasatConfig>): MigrationStore;
+  createTable(tableName: string, tableCreator: (table: TableBuilder) => void): MigrationStore;
+  dropTable(tableName: string): MigrationStore;
+  table(tableName: string): MigrationTable;
+  sql(...sql: string[]): MigrationStore;
+  setConfig(config: NestedPartial<SasatConfig>): MigrationStore;
 }
-
-type TypeFieldDefinition = {
-    return: string;
-    args?: {
-        name: string;
-        type: string;
-    }[];
-};
-
+//#endregion
+//#region src/migration/front/migration.d.ts
 interface SasatMigration {
-    up: (store: MigrationStore) => void | Promise<void>;
-    down: (store: MigrationStore) => void | Promise<void>;
-    beforeUp?: () => void | Promise<void>;
-    afterUp?: () => void | Promise<void>;
-    beforeDown?: () => void | Promise<void>;
-    afterDown?: () => void | Promise<void>;
+  up: (store: MigrationStore) => void | Promise<void>;
+  down: (store: MigrationStore) => void | Promise<void>;
+  beforeUp?: () => void | Promise<void>;
+  afterUp?: () => void | Promise<void>;
+  beforeDown?: () => void | Promise<void>;
+  afterDown?: () => void | Promise<void>;
 }
-
-type StrOrNum = string | number;
-type ValueType = string | boolean | number | null;
-declare const QExpr: {
-    readonly field: (table: string, name: string, alias?: string) => Field;
-    readonly fn: (fnName: string, args: Value[], alias?: string) => Fn;
-    readonly window: (type: 'ROWS' | 'RANGE', value: WindowContent) => Window;
-    readonly windowBetween: (type: 'ROWS' | 'RANGE', start: WindowContent, end: WindowContent) => Window;
-    readonly paren: (expression: BooleanValueExpression) => ParenthesisExpression;
-    readonly table: (name: string, joins: Join[], alias: string) => QueryTable;
-    readonly subQueryTable: (query: Query, joins: Join[], alias: string) => QueryTable;
-    readonly join: (table: QueryTable, conditions: BooleanValueExpression, type?: JoinType) => Join;
-    readonly value: (value: ValueType) => Literal;
-    readonly sort: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
-    readonly order: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
-    readonly ident: (identifier: string) => Identifier;
-    readonly id: (identifier: string) => Identifier;
-    readonly raw: (sql: string) => RawExpression;
-    readonly simpleWhere: (tableNameOrAlias: string, where: {
-        [field: string]: ValueType | [ComparisonOperators, ValueType];
-    }, isOr?: boolean) => BooleanValueExpression;
-    readonly and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-    readonly or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-    readonly eq: (left: Value, right: Value) => ComparisonExpression;
-    readonly neq: (left: Value, right: Value) => ComparisonExpression;
-    readonly gt: (left: Value, right: Value) => ComparisonExpression;
-    readonly gte: (left: Value, right: Value) => ComparisonExpression;
-    readonly lt: (left: Value, right: Value) => ComparisonExpression;
-    readonly lte: (left: Value, right: Value) => ComparisonExpression;
-    readonly comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
-    readonly contains: (left: Value, right: string) => BooleanValueExpression;
-    readonly notContains: (left: Value, right: string) => BooleanValueExpression;
-    readonly startsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly notStartsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly endsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly notEndsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
-    readonly notIn: (left: Value, values: StrOrNum[]) => InExpression;
-    readonly between: (left: Value, begin: Value, end: Value) => BetweenExpression;
-    readonly isNull: (expr: Value) => IsNullExpression;
-    readonly isNotNull: (expr: Value) => IsNullExpression;
-    readonly exists: (query: RawExpression | Query) => ExistsExpression;
-    readonly conditions: {
-        simpleWhere: (tableNameOrAlias: string, where: {
-            [field: string]: ValueType | [ComparisonOperators, ValueType];
-        }, isOr?: boolean) => BooleanValueExpression;
-        and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-        or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-        eq: (left: Value, right: Value) => ComparisonExpression;
-        neq: (left: Value, right: Value) => ComparisonExpression;
-        gt: (left: Value, right: Value) => ComparisonExpression;
-        gte: (left: Value, right: Value) => ComparisonExpression;
-        lt: (left: Value, right: Value) => ComparisonExpression;
-        lte: (left: Value, right: Value) => ComparisonExpression;
-        comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
-        contains: (left: Value, right: string) => BooleanValueExpression;
-        notContains: (left: Value, right: string) => BooleanValueExpression;
-        startsWith: (left: Value, right: string) => BooleanValueExpression;
-        notStartsWith: (left: Value, right: string) => BooleanValueExpression;
-        endsWith: (left: Value, right: string) => BooleanValueExpression;
-        notEndsWith: (left: Value, right: string) => BooleanValueExpression;
-        in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
-        notIn: (left: Value, values: StrOrNum[]) => InExpression;
-        between: (left: Value, begin: Value, end: Value) => BetweenExpression;
-        isNull: (expr: Value) => IsNullExpression;
-        isNotNull: (expr: Value) => IsNullExpression;
-        exists: (query: RawExpression | Query) => ExistsExpression;
-    };
+//#endregion
+//#region src/migration/makeCondition.d.ts
+declare const Conditions: {
+  readonly betweenRel: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
+  readonly betweenQuery: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
+  readonly custom: (conditionName: string, parentRequiredFields?: string[], childRequiredFields?: string[]) => JoinConditionNode;
+  readonly rel: {
+    readonly between: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
+    readonly comparison: (left: JoinConditionValue, operator: ComparisonOperators, right: JoinConditionValue) => JoinConditionNode;
+    readonly in: (left: JoinConditionValue, right: JoinConditionValue[]) => JoinConditionNode;
+    readonly isNull: (value: JoinConditionValue) => JoinConditionNode;
+    readonly isNotNull: (value: JoinConditionValue) => JoinConditionNode;
+  };
+  readonly query: {
+    readonly between: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
+    readonly comparison: (left: QueryConditionValue, operator: ComparisonOperators, right: QueryConditionValue) => QueryConditionNode;
+  };
+  readonly value: {
+    readonly parent: (field: string) => JoinConditionValue;
+    readonly child: (field: string) => JoinConditionValue;
+    readonly contextOrError: (field: string, errorMessage: string) => ConditionValue;
+    readonly contextOrDefault: (field: string, defaultValue: string | number) => ConditionValue;
+    readonly fixed: (value: string | number) => ConditionValue;
+    readonly today: (thresholdHour?: number, date?: boolean) => ConditionValue;
+    readonly now: () => ConditionValue;
+    readonly field: (column: string) => QueryConditionValue;
+    readonly arg: (name: string, type: "Int" | "Float" | "String") => QueryConditionValue;
+  };
+  readonly range: {
+    readonly values: (begin: JoinConditionValue, end: JoinConditionValue) => JoinConditionRangeValue;
+    readonly today: (thresholdHour?: number) => JoinConditionRangeValue;
+  };
 };
-
-declare const gqlResolveInfoToField: <T extends Fields<any> = Fields<unknown>>(info: GraphQLResolveInfo$1) => T;
-
-declare const getCurrentDateTimeString: () => string;
-
-declare const getDbClient: (connectionOption?: Partial<mysql2.ConnectionOptions> | undefined, poolOption?: Partial<mysql2.PoolOptions> | undefined, logger?: ((query: string) => void) | undefined) => DBClient;
-
-type Obj = {
-    [key: string]: any;
+//#endregion
+//#region src/migration/makeMutaion.d.ts
+type Option = {
+  noRefetch?: boolean;
+  middlewares?: string[];
+  contextFields?: GqlFromContextParam[];
+  subscription?: {
+    enabled: boolean;
+    subscriptionFilter?: string[];
+  } | boolean;
 };
-declare const assignDeep: (base: Obj, ...objects: Obj[]) => Obj;
-
+declare const Mutations: {
+  create: (options?: Option) => GQLMutation;
+  update: (options?: Option) => GQLMutation;
+  delete: (options?: Omit<Option, "noRefetch">) => GQLMutation;
+};
+//#endregion
+//#region src/migration/makeQuery.d.ts
+declare const Queries: {
+  single: (name: string, options?: {
+    conditions?: QueryConditionNode[];
+    middlewares?: string[];
+  }) => GQLQuery;
+  listAll: (name: string, options?: {
+    conditions?: QueryConditionNode[];
+    middlewares?: string[];
+  }) => GQLQuery;
+  paging: (name: string, options?: {
+    conditions?: QueryConditionNode[];
+    middlewares?: string[];
+  }) => GQLQuery;
+  primary: (middlewares?: string[]) => GQLQuery;
+};
+//#endregion
+//#region src/runtime/createTypeDef.d.ts
 type TypeDef = Record<string, TypeFieldDefinition>;
 declare const createTypeDef: (typeDefs: Record<string, TypeDef>, inputs: Record<string, TypeDef>) => string;
-
-type ConditionExpression<T> = ComparisonExpression$1<T> | CompositeCondition<T>;
-
-declare class CompositeCondition<T> {
-    private type;
-    private conditions;
-    private constructor();
-    static or<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
-    static and<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
-    toSQL(): string;
-}
-
+//#endregion
+//#region src/runtime/date.d.ts
 declare const dateOffset: (date: Date, timeZoneHour?: number) => Date;
 declare const dateToDatetimeString: (d: Date) => string;
 declare const dateToDateString: (d: Date) => string;
@@ -1148,20 +1073,155 @@ declare const getTodayDateString: (timeZoneHour?: number) => string;
 declare const getTodayDateTimeString: (timeZoneHour?: number) => string;
 declare const getDayRange: (date: Date, timeZoneHour?: number) => [string, string];
 declare const getDayRangeQExpr: (date: Date, timeZoneHour?: number) => [Literal, Literal];
-
+//#endregion
+//#region src/runtime/dsl/factory.d.ts
+type StrOrNum = string | number;
+type ValueType = string | boolean | number | null;
+declare const QExpr: {
+  readonly field: (table: string, name: string, alias?: string) => Field;
+  readonly fn: (fnName: string, args: Value[], alias?: string) => Fn;
+  readonly window: (type: "ROWS" | "RANGE", value: WindowContent) => Window;
+  readonly windowBetween: (type: "ROWS" | "RANGE", start: WindowContent, end: WindowContent) => Window;
+  readonly paren: (expression: BooleanValueExpression) => ParenthesisExpression;
+  readonly table: (name: string, joins: Join[], alias: string) => QueryTable;
+  readonly subQueryTable: (query: Query, joins: Join[], alias: string) => QueryTable;
+  readonly join: (table: QueryTable, conditions: BooleanValueExpression, type?: JoinType) => Join;
+  readonly value: (value: ValueType) => Literal;
+  readonly sort: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
+  readonly order: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
+  readonly ident: (identifier: string) => Identifier;
+  readonly id: (identifier: string) => Identifier;
+  readonly raw: (sql: string) => RawExpression;
+  readonly simpleWhere: (tableNameOrAlias: string, where: {
+    [field: string]: ValueType | [ComparisonOperators, ValueType];
+  }, isOr?: boolean) => BooleanValueExpression;
+  readonly and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
+  readonly or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
+  readonly eq: (left: Value, right: Value) => ComparisonExpression;
+  readonly neq: (left: Value, right: Value) => ComparisonExpression;
+  readonly gt: (left: Value, right: Value) => ComparisonExpression;
+  readonly gte: (left: Value, right: Value) => ComparisonExpression;
+  readonly lt: (left: Value, right: Value) => ComparisonExpression;
+  readonly lte: (left: Value, right: Value) => ComparisonExpression;
+  readonly comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
+  readonly contains: (left: Value, right: string) => BooleanValueExpression;
+  readonly notContains: (left: Value, right: string) => BooleanValueExpression;
+  readonly startsWith: (left: Value, right: string) => BooleanValueExpression;
+  readonly notStartsWith: (left: Value, right: string) => BooleanValueExpression;
+  readonly endsWith: (left: Value, right: string) => BooleanValueExpression;
+  readonly notEndsWith: (left: Value, right: string) => BooleanValueExpression;
+  readonly in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
+  readonly notIn: (left: Value, values: StrOrNum[]) => InExpression;
+  readonly between: (left: Value, begin: Value, end: Value) => BetweenExpression;
+  readonly isNull: (expr: Value) => IsNullExpression;
+  readonly isNotNull: (expr: Value) => IsNullExpression;
+  readonly exists: (query: RawExpression | Query) => ExistsExpression;
+  readonly conditions: {
+    simpleWhere: (tableNameOrAlias: string, where: {
+      [field: string]: ValueType | [ComparisonOperators, ValueType];
+    }, isOr?: boolean) => BooleanValueExpression;
+    and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
+    or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
+    eq: (left: Value, right: Value) => ComparisonExpression;
+    neq: (left: Value, right: Value) => ComparisonExpression;
+    gt: (left: Value, right: Value) => ComparisonExpression;
+    gte: (left: Value, right: Value) => ComparisonExpression;
+    lt: (left: Value, right: Value) => ComparisonExpression;
+    lte: (left: Value, right: Value) => ComparisonExpression;
+    comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
+    contains: (left: Value, right: string) => BooleanValueExpression;
+    notContains: (left: Value, right: string) => BooleanValueExpression;
+    startsWith: (left: Value, right: string) => BooleanValueExpression;
+    notStartsWith: (left: Value, right: string) => BooleanValueExpression;
+    endsWith: (left: Value, right: string) => BooleanValueExpression;
+    notEndsWith: (left: Value, right: string) => BooleanValueExpression;
+    in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
+    notIn: (left: Value, values: StrOrNum[]) => InExpression;
+    between: (left: Value, begin: Value, end: Value) => BetweenExpression;
+    isNull: (expr: Value) => IsNullExpression;
+    isNotNull: (expr: Value) => IsNullExpression;
+    exists: (query: RawExpression | Query) => ExistsExpression;
+  };
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/nodeToSql.d.ts
+declare const Sql: {
+  select: (expr: SelectExpr) => string;
+  literal: (literal: Literal) => string;
+  fieldInCondition: (identifier: Field) => string;
+  fieldInSelect: (identifier: Field) => string;
+  identifier: (ident: Identifier) => string;
+  fn: (fn: Fn) => string;
+  value: (v: Value) => string;
+  between: (expr: BetweenExpression) => string;
+  contains: (expr: ContainsExpression) => string;
+  in: (expr: InExpression) => string;
+  comparison: (expr: ComparisonExpression) => string;
+  compound: (expr: CompoundExpression) => string;
+  isNull: (expr: IsNullExpression) => string;
+  paren: (expr: ParenthesisExpression) => string;
+  table: (table: QueryTable) => string;
+  join: (join: Join) => string;
+  booleanValue: (expr: BooleanValueExpression) => string;
+  exists: (expr: ExistsExpression) => string;
+  sort: (expr: Sort) => string;
+  sorts: (sorts: Sort[]) => string;
+  queryOrRaw: (expr: Query | RawExpression) => string;
+};
+//#endregion
+//#region src/runtime/gqlResolveInfoToField.d.ts
+declare const gqlResolveInfoToField: <T extends Fields<unknown> = Fields<unknown>>(info: GraphQLResolveInfo) => T;
+//#endregion
+//#region src/runtime/id.d.ts
+type NumberIdEncoder = {
+  encode: (id: number) => string;
+  decode: (id: string) => number;
+};
+declare const makeNumberIdEncoder: (hashId: Hashids) => NumberIdEncoder;
+//#endregion
+//#region src/runtime/resolverMiddleware.d.ts
+type ResolverMiddleware<Context, RequiredParams = any, IncomingParams = RequiredParams> = (args: ResolverArgs<Context, IncomingParams | RequiredParams>) => ResolverArgs<Context, RequiredParams | IncomingParams>;
+declare const makeParamsMiddleware: <RequiredParams, IncomingParams = RequiredParams>(update: (params: RequiredParams) => IncomingParams) => ResolverMiddleware<never, RequiredParams, IncomingParams>;
+//#endregion
+//#region src/runtime/makeResolver.d.ts
+type ResolverArgs<Context, Params = unknown> = [_: unknown, params: Params, context: Context, info: GraphQLResolveInfo$1];
+type Resolver<Context, Params> = (_: unknown, params: Params, context: Context, info: GraphQLResolveInfo$1) => unknown;
+declare const makeResolver: <Context, RequiredParams, IncomingParams = RequiredParams>(resolver: Resolver<Context, RequiredParams>, middlewares?: ResolverMiddleware<Context, RequiredParams, IncomingParams>[]) => Resolver<Context, RequiredParams>;
+//#endregion
+//#region src/runtime/sql/sqlString.d.ts
+declare const escape: typeof pkg.escape;
+declare const SqlString: {
+  escape: (value: Parameters<typeof escape>[0]) => string;
+  escapeId: (name: string) => string;
+};
+//#endregion
+//#region src/runtime/types.d.ts
+type CustomCondition<Context> = (args: MakeConditionArg<Context>) => BooleanValueExpression;
+//#endregion
+//#region src/runtime/util.d.ts
 declare const pick: <T extends object>(target: T, keys: Array<keyof T>) => {
-    [k: string]: T[keyof T];
+  [k: string]: T[keyof T];
 };
-
+//#endregion
+//#region src/util/assignDeep.d.ts
+type Obj = {
+  [key: string]: any;
+};
+declare const assignDeep: (base: Obj, ...objects: Obj[]) => Obj;
+//#endregion
+//#region src/util/dateUtil.d.ts
+declare const getCurrentDateTimeString: () => string;
+//#endregion
+//#region src/runtime/pagingOption.d.ts
 type DsPagingOption = {
-    numberOfItem: number;
-    where?: BooleanValueExpression;
-    offset?: number;
-    sort?: Sort[];
+  numberOfItem: number;
+  where?: BooleanValueExpression;
+  offset?: number;
+  sort?: Sort[];
 };
-declare const pagingOption: (option: ListQueryOption) => DsPagingOption;
-
+declare const pagingOption$1: (option: ListQueryOption) => DsPagingOption;
+//#endregion
+//#region src/index.d.ts
 type PagingOption = ListQueryOption;
-
-export { CompositeCondition, Conditions, Mutations, QExpr, Queries, SQLClient, SQLTransaction, SasatDBDatasource, Sql, SqlString, assignDeep, createTypeDef, dateOffset, dateToDateString, dateToDatetimeString, formatQuery, getCurrentDateTimeString, getDayRange, getDayRangeQExpr, getDbClient, getTodayDateString, getTodayDateTimeString, gqlResolveInfoToField, makeNumberIdEncoder, makeParamsMiddleware, makeResolver, pagingOption, pick, QExpr as qe, queryToSql, setConfig };
-export type { BooleanValueExpression, CommandResponse, ComparisonOperators, CustomCondition, EntityResult, EntityType, Fields, ListQueryOption, LockMode, MigrationStore, PagingOption, Query, QueryOptions, QueryResponse, Relation, RelationMap, ResolverMiddleware, SQLExecutor, SasatMigration, TableInfo, TypeFieldDefinition };
+//#endregion
+export { type BooleanValueExpression, type CommandResponse, type ComparisonOperators, CompositeCondition, Conditions, type CustomCondition, type EntityResult, type EntityType, type Fields, type ListQueryOption, type LockMode, type MigrationStore, Mutations, MysqlClient, PagingOption, QExpr, QExpr as qe, Queries, type Query, type QueryOptions, type QueryResponse, type Relation, type RelationMap, type ResolverMiddleware, type SQLClient, type SQLExecutor, type SQLTransaction, SasatDBDatasource, type SasatMigration, Sql, SqlString, type TableInfo, type TypeFieldDefinition, assignDeep, createTypeDef, dateOffset, dateToDateString, dateToDatetimeString, formatQuery, getCurrentDateTimeString, getDayRange, getDayRangeQExpr, getDbClient, getTodayDateString, getTodayDateTimeString, gqlResolveInfoToField, makeNumberIdEncoder, makeParamsMiddleware, makeResolver, migrate, pagingOption$1 as pagingOption, pick, queryToSql, setConfig };