@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/query/QueryBuilder.d.ts

@@ -0,0 +1,389 @@
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityManager, type EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterOptions, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type Transaction } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
+import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { Field, ICriteriaNodeProcessOptions, JoinOptions } from '../typings.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+export interface ExecuteOptions {
+    mapResults?: boolean;
+    mergeResults?: boolean;
+}
+export interface QBStreamOptions {
+    /**
+     * Results are mapped to entities, if you set `mapResults: false` you will get POJOs instead.
+     *
+     * @default true
+     */
+    mapResults?: boolean;
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * one item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+    /**
+     * When enabled, the driver will return the raw database results without renaming the fields to match the entity property names.
+     *
+     * @default false
+     */
+    rawResults?: boolean;
+}
+type AnyString = string & {};
+type Compute<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
+type GetAlias<T extends string> = T extends `${infer A}.${string}` ? A : never;
+type GetPropName<T extends string> = T extends `${string}.${infer P}` ? P : T;
+type AppendToHint<Parent extends string, Child extends string> = `${Parent}.${Child}`;
+type AddToContext<Type extends object, Context, Field extends string, Alias extends string, Select extends boolean> = {
+    [K in Alias]: [GetPath<Context, Field>, K, ExpandProperty<Type[GetPropName<Field> & keyof Type]>, Select];
+};
+type GetPath<Context, Field extends string> = GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? GetPropName<Field> : Alias extends keyof Context ? Context[Alias] extends [infer Path, ...any[]] ? AppendToHint<Path & string, GetPropName<Field>> : GetPropName<Field> : GetPropName<Field> : GetPropName<Field>;
+type GetType<Type extends object, Context, Field extends string> = GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? Type : Alias extends keyof Context ? Context[Alias] extends [string, string, infer PropType] ? PropType & object : Type : Type : Type;
+type AddToHint<RootAlias, Context, Field extends string, Select extends boolean = false> = Select extends true ? GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? GetPropName<Field> : Alias extends RootAlias ? GetPropName<Field> : Alias extends keyof Context ? Context[Alias] extends [infer Path, ...any[]] ? AppendToHint<Path & string, GetPropName<Field>> : GetPropName<Field> : GetPropName<Field> : GetPropName<Field> : never;
+export type ModifyHint<RootAlias, Context, Hint extends string, Field extends string, Select extends boolean = false> = Hint | AddToHint<RootAlias, Context, Field, Select>;
+export type ModifyContext<Entity extends object, Context, Field extends string, Alias extends string, Select extends boolean = false> = Compute<IsNever<Context> extends true ? AddToContext<GetType<Entity, object, Field>, object, Field, Alias, Select> : Context & AddToContext<GetType<Entity, Context, Field>, Context, Field, Alias, Select>>;
+type EntityRelations<T> = EntityKey<T, true>;
+type AddAliasesFromContext<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${EntityRelations<Type & {}>}` : never : never : never;
+export type QBField<Entity, RootAlias extends string, Context> = (EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | AddAliasesFromContext<Context>) & {} | AnyString;
+type EntityKeyOrString<Entity extends object = AnyEntity> = AnyString | keyof Entity;
+/**
+ * SQL query builder with fluent interface.
+ *
+ * ```ts
+ * const qb = orm.em.createQueryBuilder(Publisher);
+ * qb.select('*')
+ *   .where({
+ *     name: 'test 123',
+ *     type: PublisherType.GLOBAL,
+ *   })
+ *   .orderBy({
+ *     name: QueryOrder.DESC,
+ *     type: QueryOrder.ASC,
+ *   })
+ *   .limit(2, 1);
+ *
+ * const publisher = await qb.getSingleResult();
+ * ```
+ */
+export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> {
+    protected readonly metadata: MetadataStorage;
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly context?: Transaction | undefined;
+    protected connectionType?: ConnectionType | undefined;
+    protected em?: SqlEntityManager | undefined;
+    protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
+    get mainAlias(): Alias<Entity>;
+    get alias(): string;
+    get helper(): QueryBuilderHelper;
+    get type(): QueryType;
+    /** @internal */
+    _type?: QueryType;
+    /** @internal */
+    _fields?: Field<Entity>[];
+    /** @internal */
+    _populate: PopulateOptions<Entity>[];
+    /** @internal */
+    _populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    /** @internal */
+    _populateFilter?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    /** @internal */
+    __populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    /** @internal */
+    _populateMap: Dictionary<string>;
+    /** @internal */
+    readonly rawFragments: Set<string>;
+    protected aliasCounter: number;
+    protected flags: Set<QueryFlag>;
+    protected finalized: boolean;
+    protected populateHintFinalized: boolean;
+    protected _joins: Dictionary<JoinOptions>;
+    protected _explicitAlias: boolean;
+    protected _schema?: string;
+    protected _cond: Dictionary;
+    protected _data: Dictionary;
+    protected _orderBy: QueryOrderMap<Entity>[];
+    protected _groupBy: Field<Entity>[];
+    protected _having: Dictionary;
+    protected _returning?: Field<Entity>[];
+    protected _onConflict?: OnConflictClause<Entity>[];
+    protected _limit?: number;
+    protected _offset?: number;
+    protected _distinctOn?: string[];
+    protected _joinedProps: Map<string, PopulateOptions<any>>;
+    protected _cache?: boolean | number | [string, number];
+    protected _indexHint?: string;
+    protected _comments: string[];
+    protected _hintComments: string[];
+    protected flushMode?: FlushMode;
+    protected lockMode?: LockMode;
+    protected lockTables?: string[];
+    protected subQueries: Dictionary<string>;
+    protected _mainAlias?: Alias<Entity>;
+    protected _aliases: Dictionary<Alias<any>>;
+    protected _helper?: QueryBuilderHelper;
+    protected _query?: {
+        sql?: string;
+        params?: readonly unknown[];
+        qb: NativeQueryBuilder;
+    };
+    protected readonly platform: AbstractSqlPlatform;
+    /**
+     * @internal
+     */
+    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
+    select(fields: Field<Entity> | Field<Entity>[], distinct?: boolean): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    addSelect(fields: Field<Entity> | Field<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    distinct(): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    /** postgres only */
+    distinctOn(fields: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity>;
+    update(data: EntityData<Entity>): UpdateQueryBuilder<Entity>;
+    delete(cond?: QBFilterQuery): DeleteQueryBuilder<Entity>;
+    truncate(): TruncateQueryBuilder<Entity>;
+    count(field?: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[], distinct?: boolean): CountQueryBuilder<Entity>;
+    join<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    innerJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    innerJoinLateral(field: RawQueryFragment | QueryBuilder<any>, alias: string, cond: QBFilterQuery, schema?: string): this;
+    leftJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | RawQueryFragment | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    leftJoinLateral(field: RawQueryFragment | QueryBuilder<any>, alias: string, cond: QBFilterQuery, schema?: string): this;
+    joinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    leftJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    leftJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: [field: Field, qb: RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    innerJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    innerJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: [field: Field, qb: RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    protected getFieldsForJoinedLoad(prop: EntityProperty<Entity>, alias: string, explicitFields?: string[]): Field<Entity>[];
+    /**
+     * Apply filters to the QB where condition.
+     */
+    applyFilters(filterOptions?: FilterOptions): Promise<void>;
+    private readonly autoJoinedPaths;
+    /**
+     * @internal
+     */
+    scheduleFilterCheck(path: string): void;
+    /**
+     * @internal
+     */
+    applyJoinedFilters(em: EntityManager, filterOptions: FilterOptions | undefined): Promise<void>;
+    withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
+    where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
+    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
+    andWhere(cond: QBFilterQuery<Entity>): this;
+    andWhere(cond: string, params?: any[]): this;
+    orWhere(cond: QBFilterQuery<Entity>): this;
+    orWhere(cond: string, params?: any[]): this;
+    orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    andOrderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    private processOrderBy;
+    groupBy(fields: EntityKeyOrString<Entity> | readonly EntityKeyOrString<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    having(cond?: QBFilterQuery | string, params?: any[], operator?: keyof typeof GroupOperator): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    andHaving(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    orHaving(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    onConflict(fields?: Field<Entity> | Field<Entity>[]): InsertQueryBuilder<Entity>;
+    ignore(): this;
+    merge(data?: EntityData<Entity> | Field<Entity>[]): this;
+    returning(fields?: Field<Entity> | Field<Entity>[]): this;
+    /**
+     * @internal
+     */
+    populate(populate: PopulateOptions<Entity>[], populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`, populateFilter?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`): this;
+    limit(limit?: number, offset?: number): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    offset(offset?: number): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    withSchema(schema?: string): this;
+    setLockMode(mode?: LockMode, tables?: string[]): this;
+    setFlushMode(flushMode?: FlushMode): this;
+    setFlag(flag: QueryFlag): this;
+    unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
+    cache(config?: boolean | number | [string, number]): this;
+    /**
+     * Adds index hint to the FROM clause.
+     */
+    indexHint(sql: string | undefined): this;
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
+     */
+    comment(comment: string | string[] | undefined): this;
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *&#8205;/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment: string | string[] | undefined): this;
+    /**
+     * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
+     * Allows setting a main string alias of the selection data.
+     */
+    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
+    /**
+     * @internal
+     */
+    clearRawFragmentsCache(): void;
+    /**
+     * Returns the query with parameters as wildcards.
+     */
+    getQuery(): string;
+    /**
+     * Returns raw fragment representation of this QueryBuilder.
+     */
+    toRaw(): RawQueryFragment;
+    toQuery(): {
+        sql: string;
+        params: readonly unknown[];
+    };
+    /**
+     * Returns the list of all parameters for this query.
+     */
+    getParams(): readonly unknown[];
+    /**
+     * Returns raw interpolated query string with all the parameters inlined.
+     */
+    getFormattedQuery(): string;
+    /**
+     * @internal
+     */
+    getAliasForJoinPath(path?: string | JoinOptions, options?: ICriteriaNodeProcessOptions): string | undefined;
+    /**
+     * @internal
+     */
+    getJoinForPath(path: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
+    /**
+     * @internal
+     */
+    getNextAlias(entityName?: string): string;
+    /**
+     * @internal
+     */
+    getAliasMap(): Dictionary<string>;
+    /**
+     * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
+     * Use `method` to specify what kind of result you want to get (array/single/meta).
+     */
+    execute<U = any>(method?: 'all' | 'get' | 'run', options?: ExecuteOptions | boolean): Promise<U>;
+    private getConnection;
+    /**
+     * Executes the query and returns an async iterable (async generator) that yields results one by one.
+     * By default, the results are merged and mapped to entity instances, without adding them to the identity map.
+     * You can disable merging and mapping by passing the options `{ mergeResults: false, mapResults: false }`.
+     * This is useful for processing large datasets without loading everything into memory at once.
+     *
+     * ```ts
+     * const qb = em.createQueryBuilder(Book, 'b');
+     * qb.select('*').where({ title: '1984' }).leftJoinAndSelect('b.author', 'a');
+     *
+     * for await (const book of qb.stream()) {
+     *   // book is an instance of Book entity
+     *   console.log(book.title, book.author.name);
+     * }
+     * ```
+     */
+    stream(options?: QBStreamOptions): AsyncIterableIterator<Loaded<Entity, Hint>>;
+    /**
+     * Alias for `qb.getResultList()`
+     */
+    getResult(): Promise<Loaded<Entity, Hint>[]>;
+    /**
+     * Executes the query, returning array of results mapped to entity instances.
+     */
+    getResultList(limit?: number): Promise<Loaded<Entity, Hint>[]>;
+    private propagatePopulateHint;
+    private mapResult;
+    private mapResults;
+    /**
+     * Executes the query, returning the first result or null
+     */
+    getSingleResult(): Promise<Entity | null>;
+    /**
+     * Executes count query (without offset and limit), returning total count of results
+     */
+    getCount(field?: EntityKeyOrString<Entity> | EntityKeyOrString<Entity>[], distinct?: boolean): Promise<number>;
+    /**
+     * Executes the query, returning both array of results and total count query (without offset and limit).
+     */
+    getResultAndCount(): Promise<[Entity[], number]>;
+    /**
+     * Returns native query builder instance with sub-query aliased with given alias.
+     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
+     */
+    as(alias: string): NativeQueryBuilder;
+    clone(reset?: boolean | string[]): QueryBuilder<Entity>;
+    /**
+     * Sets logger context for this query builder.
+     */
+    setLoggerContext(context: LoggingOptions & Dictionary): void;
+    /**
+     * Gets logger context for this query builder.
+     */
+    getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
+    private fromVirtual;
+    private joinReference;
+    protected prepareFields<T>(fields: Field<T>[], type?: 'where' | 'groupBy' | 'sub-query'): (string | RawQueryFragment)[];
+    private init;
+    private getQueryBase;
+    private applyDiscriminatorCondition;
+    private finalize;
+    /** @internal */
+    processPopulateHint(): void;
+    private processPopulateWhere;
+    private mergeOnConditions;
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    private processNestedJoins;
+    private hasToManyJoins;
+    protected wrapPaginateSubQuery(meta: EntityMetadata): void;
+    private pruneExtraJoins;
+    private wrapModifySubQuery;
+    private getSchema;
+    private createAlias;
+    private createMainAlias;
+    private fromSubQuery;
+    private fromEntityName;
+    private createQueryBuilderHelper;
+    private ensureFromClause;
+    private ensureNotFinalized;
+}
+export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
+    where(cond: QBFilterQuery<Entity> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
+    execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+}
+export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
+    execute<Result = Entity[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = Entity[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = Entity>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
+}
+export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {
+    execute<Result = {
+        count: number;
+    }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = {
+        count: number;
+    }[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = {
+        count: number;
+    }>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = QueryResult<{
+        count: number;
+    }>>(method: 'run', mapResults?: boolean): Promise<Result>;
+}
+export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface UpdateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface DeleteQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface TruncateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export {};