sasat 0.22.4 → 0.22.5

package/dist/migration/index.d.cts

@@ -0,0 +1,657 @@
+import { a as NestedPartial, n as ComparisonOperators, r as SasatConfig } from "../comparison-CIb9xu5T.cjs";
+import { s as SqlValueType } from "../dbClient-Bnk1JKBU.cjs";
+
+//#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;
+};
+type FixedConditionValue = {
+  kind: "fixed";
+  value: string | number;
+};
+type TodayStartConditionValue = {
+  kind: "today";
+  type: "date" | "datetime";
+  thresholdHour?: number;
+};
+type NowConditionValue = {
+  kind: "now";
+};
+type OnNotDefinedAction = {
+  action: "error";
+  message: string;
+} | {
+  action: "defaultValue";
+  value: string | number;
+};
+type ConditionValue = ContextConditionValue | FixedConditionValue | TodayStartConditionValue | NowConditionValue;
+//#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 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[];
+};
+//#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;
+};
+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;
+}
+interface SerializedNormalColumn extends SerializedColumnBase {
+  hasReference: false;
+}
+interface Reference {
+  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;
+}
+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[];
+}
+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;
+}
+//#endregion
+//#region src/migration/serialized/serializedStore.d.ts
+interface SerializedTable {
+  columns: SerializedColumn[];
+  primaryKey: string[];
+  uniqueKeys: string[][];
+  indexes: Index[];
+  tableName: string;
+  gqlOption: GQLOption;
+  virtualRelations: VirtualRelation[];
+}
+//#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;
+}
+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;
+}
+declare class ReferenceColumn extends BaseColumn {
+  data: SerializedReferenceColumn;
+  constructor(data: SerializedReferenceColumn, table: Table);
+  getConstraintName(): string;
+}
+//#endregion
+//#region src/migration/dataStore.d.ts
+interface DataStore {
+  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;
+}
+type GQLMutation = {
+  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: "primary";
+  name?: never;
+  conditions: never[];
+  middlewares: string[];
+};
+interface GQLOption {
+  enabled: boolean;
+  queries: GQLQuery[];
+  mutations: GQLMutation[];
+}
+//#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;
+  };
+}
+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;
+  };
+}
+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;
+}
+declare class TextColumnBuilder extends ColumnBuilder {
+  readonly name: string;
+  protected type: DBTextTypes;
+  constructor(name: string, type: DBTextTypes);
+  default(value: string | null | undefined): this;
+}
+declare class NumberColumnBuilder extends ColumnBuilder {
+  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;
+}
+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;
+}
+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);
+}
+declare class DateColumnBuilder extends ColumnBuilder {
+  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;
+}
+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;
+  };
+}
+//#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;
+}
+//#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;
+}
+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;
+}
+//#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<SasatConfig>): MigrationStore;
+}
+//#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>;
+}
+//#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;
+  };
+};
+//#endregion
+//#region src/migration/makeMutaion.d.ts
+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;
+};
+//#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
+export { Conditions, type MigrationStore, Mutations, Queries, type Relation, type SasatMigration };