vona-module-a-orm 5.0.37

package/dist/bean/bean.databaseDialectBase.d.ts

@@ -0,0 +1,20 @@
+import type { Knex } from 'knex';
+import type { ITableColumn } from '../types/columns.ts';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IFetchDatabasesResultItem, IFetchIndexesResultItem } from '../types/dialect.ts';
+import type { TableIdentity } from '../types/tableIdentity.ts';
+import { BeanBase } from 'vona';
+export declare class BeanDatabaseDialectBase extends BeanBase {
+    getConfigBase(): ConfigDatabaseClient | undefined;
+    fetchDatabases(_schemaBuilder: Knex.SchemaBuilder, _databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+    createDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<void>;
+    dropDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<void>;
+    fetchIndexes(_schemaBuilder: Knex.SchemaBuilder, _tableName: string): Promise<IFetchIndexesResultItem[]>;
+    insert(_builder: Knex.QueryBuilder): Promise<TableIdentity[]>;
+    query(_result: any): void;
+    viewDependents(_builder: Knex.QueryBuilder, _viewName: string): Promise<string[]>;
+    coerceColumn(column: Knex.ColumnInfo): ITableColumn;
+    protected _coerceColumnValue(type: string, value: any): any;
+    protected _safeNumber(value: any): number | undefined;
+    protected _columnTypePrefixes(type: string, prefixes: string[]): boolean;
+}

package/dist/bean/bean.model/bean.model_cache.d.ts

@@ -0,0 +1,56 @@
+import type BigNumber from 'bignumber.js';
+import type { ServiceDb } from '../../service/db_.ts';
+import type { IDatabaseClientRecord, IModelDeleteOptions, IModelGetOptions, IModelInsertOptions, IModelMethodOptions, IModelMethodOptionsGeneral, IModelMutateOptions, IModelRecord, IModelSelectAggrParams, IModelSelectCountParams, IModelSelectGroupParams, IModelSelectParams, IModelUpdateOptions, ITableRecord, TableIdentity, TypeModelAggrRelationResult, TypeModelClassLikeGeneral, TypeModelGroupRelationResult, TypeModelsClassLikeGeneral, TypeModelWhere } from '../../types/index.ts';
+import { ServiceCacheEntity } from '../../service/cacheEntity_.ts';
+import { ServiceCacheQuery } from '../../service/cacheQuery_.ts';
+import { ServiceRelations } from '../../service/relations_.ts';
+import { BeanModelCrud } from './bean.model_crud.ts';
+declare const SymbolModelsClearAll: unique symbol;
+export declare class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TRecord> {
+    cacheQuery: ServiceCacheQuery;
+    cacheEntity: ServiceCacheEntity;
+    protected relations: ServiceRelations;
+    protected [SymbolModelsClearAll]: Record<keyof IModelRecord, TypeModelClassLikeGeneral[]>;
+    protected __init__(clientName?: keyof IDatabaseClientRecord | ServiceDb, table?: keyof ITableRecord): void;
+    insert<T extends IModelInsertOptions<TRecord>>(data?: Partial<TRecord>, options?: T): Promise<TRecord>;
+    insertBulk<T extends IModelInsertOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<TRecord[]>;
+    __insertBulk_raw(table: keyof ITableRecord | undefined, items: Partial<TRecord>[], options?: IModelMutateOptions<TRecord>): Promise<TRecord[]>;
+    mutate<T extends IModelMutateOptions<TRecord>>(data?: Partial<TRecord>, options?: T): Promise<Partial<TRecord>>;
+    mutateBulk<T extends IModelMutateOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<Partial<TRecord>[]>;
+    __mutateBulk_raw(table: keyof ITableRecord | undefined, items: Partial<TRecord>[], options?: IModelMutateOptions<TRecord>): Promise<TRecord[]>;
+    mget<T extends IModelGetOptions<TRecord>>(ids: TableIdentity[], options?: T): Promise<Partial<TRecord>[]>;
+    private __mget_raw;
+    count<T extends IModelSelectCountParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(params?: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+    aggregate<T extends IModelSelectAggrParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(params?: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+    private __aggregate_raw;
+    group<T extends IModelSelectGroupParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(params?: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<TRecord, T>[]>;
+    private __group_raw;
+    select<T extends IModelSelectParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(params?: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<any[]>;
+    private __select_raw;
+    private __select_cache;
+    get<T extends IModelGetOptions<TRecord>>(where: TypeModelWhere<TRecord>, options?: T): Promise<Partial<TRecord> | undefined>;
+    private __get_raw;
+    update<T extends IModelUpdateOptions<TRecord>>(data: Partial<TRecord>, options?: T): Promise<Partial<TRecord>>;
+    updateBulk<T extends IModelUpdateOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<Partial<TRecord>[]>;
+    __updateBulk_raw<T extends IModelUpdateOptions<TRecord>>(table: keyof ITableRecord | undefined, items: Partial<TRecord>[], options?: T): Promise<void>;
+    __update_raw(table: keyof ITableRecord | undefined, data: Partial<TRecord>, options?: IModelUpdateOptions<TRecord>): Promise<TableIdentity[] | void>;
+    delete<T extends IModelDeleteOptions<TRecord>>(where?: TypeModelWhere<TRecord>, options?: T): Promise<void>;
+    deleteBulk<T extends IModelDeleteOptions<TRecord>>(ids: TableIdentity[], options?: T): Promise<void>;
+    __deleteBulk_raw_with_relations<T extends IModelDeleteOptions<TRecord>>(table: keyof ITableRecord | undefined, ids: TableIdentity[], options?: T): Promise<void>;
+    __delete_raw(table: keyof ITableRecord | undefined, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptions): Promise<TableIdentity[] | void>;
+    private __get_key;
+    private __filterMGetColumns;
+    private __filterGetColumns;
+    cacheEntityDel(id: TableIdentity | TableIdentity[], table?: keyof ITableRecord): Promise<void>;
+    cacheEntityClear(table?: keyof ITableRecord): Promise<void>;
+    cacheQueryClear(table?: keyof ITableRecord): Promise<void>;
+    private _cacheQueryClearModelsClear;
+    private _getModelsClear;
+    private _getModelsClearAll;
+    private _collectModelsClearAll;
+    protected _checkDisableCacheQueryByOptions(options?: IModelMethodOptionsGeneral): boolean;
+    protected _checkDisableCacheEntityByOptions(options?: IModelMethodOptionsGeneral): boolean;
+    private __checkIfOnlyKey;
+    private __checkCacheKeyValid;
+}
+export {};

package/dist/bean/bean.model/bean.model_crud.d.ts

@@ -0,0 +1,13 @@
+import type BigNumber from 'bignumber.js';
+import type { IModelCountParams, IModelGetOptionsGeneral, IModelMethodOptionsGeneral, IModelSelectParams, IModelUpdateOptionsGeneral, TableIdentity, TypeModelWhere } from '../../types/index.ts';
+import { BeanModelCrudInner } from './bean.model_crud_inner.ts';
+export declare class BeanModelCrud<TRecord extends {} = {}> extends BeanModelCrudInner<TRecord> {
+    mget(ids: TableIdentity[], options?: IModelGetOptionsGeneral<TRecord>): Promise<Partial<TRecord>[]>;
+    select(params?: IModelSelectParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<Partial<TRecord>[]>;
+    get(where: TypeModelWhere<TRecord>, options?: IModelGetOptionsGeneral<TRecord>): Promise<Partial<TRecord> | undefined>;
+    count(params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<BigNumber | undefined>;
+    insert(data?: Partial<TRecord>, options?: IModelMethodOptionsGeneral): Promise<TRecord>;
+    insertBulk(data: Partial<TRecord>[], options?: IModelMethodOptionsGeneral): Promise<TRecord[]>;
+    update(data: Partial<TRecord>, options?: IModelUpdateOptionsGeneral<TRecord>): Promise<Partial<TRecord>>;
+    delete(where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void>;
+}

package/dist/bean/bean.model/bean.model_crud_inner.d.ts

@@ -0,0 +1,15 @@
+import type BigNumber from 'bignumber.js';
+import type { Knex } from 'knex';
+import type { IModelCountParams, IModelGetOptionsGeneral, IModelMethodOptionsGeneral, IModelSelectGeneralParams, IModelSelectParams, IModelUpdateOptionsGeneral, ITableRecord, TableIdentity, TypeModelWhere } from '../../types/index.ts';
+import { BeanModelView } from './bean.model_view.ts';
+export declare class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecord> {
+    protected _mget(table?: keyof ITableRecord, ids?: TableIdentity[], options?: IModelGetOptionsGeneral<TRecord>): Promise<TRecord[]>;
+    protected _mget_original(table?: keyof ITableRecord, ids?: TableIdentity[], options?: IModelGetOptionsGeneral<TRecord>): Promise<(TRecord | undefined)[]>;
+    protected _select<T extends IModelSelectParams<TRecord>>(table?: keyof ITableRecord, params?: T, options?: IModelMethodOptionsGeneral, builder?: Knex.QueryBuilder<TRecord, TRecord[]>): Promise<TRecord[]>;
+    protected _select_buildParams<T extends IModelSelectGeneralParams<TRecord>>(table: keyof ITableRecord, params?: T, options?: IModelMethodOptionsGeneral): Knex.QueryBuilder<TRecord, TRecord[]>;
+    protected _get(table: keyof ITableRecord | undefined, where: TypeModelWhere<TRecord>, options?: IModelGetOptionsGeneral<TRecord>): Promise<TRecord | undefined>;
+    protected _count(table?: keyof ITableRecord, params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<BigNumber | undefined>;
+    protected _insertBulk(table?: keyof ITableRecord, data?: Partial<TRecord> | Partial<TRecord>[], options?: IModelMethodOptionsGeneral): Promise<TRecord | TRecord[]>;
+    protected _update(table: keyof ITableRecord | undefined, data: Partial<TRecord>, options?: IModelUpdateOptionsGeneral<TRecord>): Promise<Partial<TRecord>>;
+    protected _delete(table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void>;
+}

package/dist/bean/bean.model/bean.model_crud_table.d.ts

@@ -0,0 +1,13 @@
+import type BigNumber from 'bignumber.js';
+import type { IModelCountParams, IModelGetOptionsGeneral, IModelMethodOptionsGeneral, IModelSelectParams, IModelUpdateOptionsGeneral, ITableRecord, TableIdentity, TypeModelWhere } from '../../types/index.ts';
+import { BeanModelCrudInner } from './bean.model_crud_inner.ts';
+export declare class BeanModelCrudTable<TRecord extends {}> extends BeanModelCrudInner<TRecord> {
+    mget(table: keyof ITableRecord, ids: TableIdentity[], options?: Omit<IModelGetOptionsGeneral<TRecord>, 'include' | 'with'>): Promise<TRecord[]>;
+    select(table: keyof ITableRecord, params?: Omit<IModelSelectParams<TRecord>, 'include' | 'with'>, options?: IModelMethodOptionsGeneral): Promise<TRecord[]>;
+    get(table: keyof ITableRecord, where: TypeModelWhere<TRecord>, options?: Omit<IModelGetOptionsGeneral<TRecord>, 'include' | 'with'>): Promise<TRecord | undefined>;
+    count(table: keyof ITableRecord, params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<BigNumber | undefined>;
+    insert(table: keyof ITableRecord, data?: Partial<TRecord>, options?: IModelMethodOptionsGeneral): Promise<TRecord>;
+    insertBulk(table: keyof ITableRecord, data: Partial<TRecord>[], options?: IModelMethodOptionsGeneral): Promise<TRecord[]>;
+    update(table: keyof ITableRecord, data: Partial<TRecord>, options?: IModelUpdateOptionsGeneral<TRecord>): Promise<Partial<TRecord>>;
+    delete(table: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void>;
+}

package/dist/bean/bean.model/bean.model_knex.d.ts

@@ -0,0 +1,15 @@
+import type { Knex } from 'knex';
+import type { IModelMethodOptionsGeneral, ITableRecord } from '../../types/index.ts';
+import { BeanModelUtils } from './bean.model_utils.ts';
+export declare class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<TRecord> {
+    get schema(): Knex.SchemaBuilder;
+    builder<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(table?: Knex.TableDescriptor): Knex.QueryBuilder<TRecord2, TResult2[]>;
+    builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(options?: IModelMethodOptionsGeneral): Knex.QueryBuilder<TRecord2, TResult2[]>;
+    builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(table: keyof ITableRecord, options?: IModelMethodOptionsGeneral): Knex.QueryBuilder<TRecord2, TResult2[]>;
+    query(value: Knex.Value): Promise<TRecord[]>;
+    query(sql: string, binding: Knex.RawBinding): Promise<TRecord[]>;
+    query(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Promise<TRecord[]>;
+    queryOne(value: Knex.Value): Promise<TRecord | undefined>;
+    queryOne(sql: string, binding: Knex.RawBinding): Promise<TRecord | undefined>;
+    queryOne(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Promise<TRecord | undefined>;
+}

package/dist/bean/bean.model/bean.model_meta.d.ts

@@ -0,0 +1,40 @@
+import type { ServiceDb } from '../../service/db_.ts';
+import type { IDatabaseClientRecord, IDecoratorModelOptions, IModelClassRecord, IModelMethodOptionsGeneral, IModelUpdateOptionsGeneral, ITableRecord, TypeEntityMeta, TypeModelClassLike, TypeModelRelationOptionsMetaClient } from '../../types/index.ts';
+import type { BeanModel } from '../bean.model.ts';
+import { BeanBase } from 'vona';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from '../../types/index.ts';
+declare const SymbolModelDb: unique symbol;
+declare const SymbolModelTable: unique symbol;
+export declare class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
+    [SymbolKeyEntity]: TRecord;
+    [SymbolKeyEntityMeta]: TypeEntityMeta<TRecord>;
+    [SymbolKeyModelOptions]: IDecoratorModelOptions;
+    private [SymbolModelDb]?;
+    private [SymbolModelTable]?;
+    protected __init__(clientName?: keyof IDatabaseClientRecord | ServiceDb, table?: keyof ITableRecord): void;
+    protected get self(): BeanModel<any>;
+    protected get connection(): import("knex").Knex<any, any[]>;
+    protected get dialect(): import("vona-module-a-orm").BeanDatabaseDialectBase;
+    get scopeOrm(): import("vona-module-a-orm").ScopeModuleAOrm;
+    get modelViewRecord(): import("vona-module-a-version").ModelViewRecord;
+    get db(): ServiceDb;
+    private _getDb;
+    getTable(): keyof ITableRecord;
+    private _getTable;
+    get options(): IDecoratorModelOptions;
+    get disableInstance(): boolean;
+    get disableDeleted(): boolean;
+    get disableCreateTime(): boolean;
+    get disableUpdateTime(): boolean;
+    protected _prepareDisableInstanceByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean): any;
+    protected _prepareDisableDeletedByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean): any;
+    protected _prepareDisableDeletedByOptionsSimple(options?: IModelMethodOptionsGeneral): boolean | undefined;
+    protected _checkIfEntityValidByDeleted(entity: any, options?: IModelMethodOptionsGeneral): boolean;
+    protected _checkDisableInstanceByOptions(options?: IModelMethodOptionsGeneral): boolean;
+    protected _checkDisableDeletedByOptions(options?: IModelMethodOptionsGeneral): boolean;
+    protected _checkDisableCreateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>): boolean;
+    protected _checkDisableUpdateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>): boolean;
+    newInstance(client?: keyof IDatabaseClientRecord | ServiceDb, table?: keyof ITableRecord): this;
+    newInstanceTarget<MODEL extends BeanModelMeta | (keyof IModelClassRecord)>(modelClassTarget: TypeModelClassLike<MODEL>, client?: TypeModelRelationOptionsMetaClient, table?: keyof ITableRecord): BeanModelMeta;
+}
+export {};

package/dist/bean/bean.model/bean.model_utils.d.ts

@@ -0,0 +1,39 @@
+import type { Knex } from 'knex';
+import type { IModelMethodOptionsGeneral, IModelSelectParamsJoin, IModelSelectParamsPage, ITableColumns, ITableRecord, TypeModelColumn, TypeModelColumns, TypeModelColumnsStrict, TypeModelSelectAggrParamsAggrs, TypeModelSelectGroupParamsColumns, TypeModelWhere } from '../../types/index.ts';
+import { BeanModelMeta } from './bean.model_meta.ts';
+export declare class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
+    prepareData(item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
+    prepareData(table: keyof ITableRecord, item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
+    defaultData(table?: keyof ITableRecord): Promise<TRecord>;
+    columns(table?: keyof ITableRecord): Promise<ITableColumns>;
+    isRaw(raw: any): boolean;
+    raw(value: Knex.Value): Knex.Raw<any>;
+    raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, binding: Knex.RawBinding): Knex.Raw<TResult2>;
+    raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Knex.Raw<TResult2>;
+    ref<TSrc extends string>(src: TSrc): Knex.Ref<TSrc, {
+        [K in TSrc]: TSrc;
+    }>;
+    toIdentifier(name: string | string[]): Knex.Raw<any>;
+    buildWhere(builder: Knex.QueryBuilder, wheres?: TypeModelWhere<TRecord>): void;
+    buildJoin(builder: Knex.QueryBuilder, join?: IModelSelectParamsJoin<TRecord, ''>): void;
+    buildJoins(builder: Knex.QueryBuilder, joins?: IModelSelectParamsJoin<TRecord, ''>[]): void;
+    buildDistinct(builder: Knex.QueryBuilder, distinct?: boolean | (keyof TRecord) | (keyof TRecord)[]): void;
+    buildCount(builder: Knex.QueryBuilder, column?: TypeModelColumn<TRecord>, distinct?: boolean | (keyof TRecord) | (keyof TRecord)[]): void;
+    buildOrders(builder: Knex.QueryBuilder, orders: any): void;
+    buildLimit(builder: Knex.QueryBuilder, limit?: number): void;
+    buildOffset(builder: Knex.QueryBuilder, offset?: number): void;
+    buildColumns(builder: Knex.QueryBuilder, columns?: TypeModelColumns<TRecord>, groups?: (keyof TRecord)[] | undefined): void;
+    buildGroups(builder: Knex.QueryBuilder, groups?: TypeModelColumnsStrict<TRecord>): (keyof TRecord)[] | undefined;
+    buildAggrs(builder: Knex.QueryBuilder, aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>): void;
+    buildPage(builder: Knex.QueryBuilder, page?: IModelSelectParamsPage): void;
+    prepareHaving(builder: Knex.QueryBuilder, having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>): void;
+    buildHaving(builder: Knex.QueryBuilder, having: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>): void;
+    prepareWhere(builder: Knex.QueryBuilder, table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): void;
+    convertItemsToBigNumber(items: {}[]): {}[];
+    extractCount(result: Array<object> | object, columnName?: string): BigNumber;
+    extractFirstNumber<T = number | BigNumber | undefined>(result: Array<object> | object, defaultValue?: T, columnName?: string): T extends undefined ? BigNumber | undefined : BigNumber;
+    extractFirstValue(result: Array<object> | object, defaultValue?: any, columnName?: string): any | undefined;
+    private _extractFirstValue;
+    protected _prepareWhereByOptions(table: keyof ITableRecord, where: any, options?: IModelMethodOptionsGeneral): any;
+    protected _prepareInsertDataByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral): any;
+}

package/dist/bean/bean.model/bean.model_view.d.ts

@@ -0,0 +1,14 @@
+import type { Knex } from 'knex';
+import { BeanModelKnex } from './bean.model_knex.ts';
+export declare class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
+    createView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void>;
+    dropView(viewName: string, disableRemoveRecord?: boolean): Promise<void>;
+    alterView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void>;
+    createTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    alterTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any, alterViewAuto?: boolean): Promise<void>;
+    viewDependents(viewName: string): Promise<string[]>;
+    viewDependentsAll(viewName: string): Promise<string[]>;
+    private _viewDependentsAll_inner;
+    private _viewDependentsAll_handle;
+}

package/dist/bean/bean.model.d.ts

@@ -0,0 +1,3 @@
+import { BeanModelCrudTable } from './bean.model/bean.model_crud_table.ts';
+export declare class BeanModel<TRecord extends {} = any> extends BeanModelCrudTable<TRecord> {
+}

package/dist/bean/bean.modelBase.d.ts

@@ -0,0 +1,3 @@
+import { BeanModelCache } from './bean.model/bean.model_cache.ts';
+export declare class BeanModelBase<TRecord extends {} = any> extends BeanModelCache<TRecord> {
+}

package/dist/bean/broadcast.columnsClear.d.ts

@@ -0,0 +1,10 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastColumnsClearJobData {
+    clientName?: keyof IDatabaseClientRecord;
+    tableName?: string;
+}
+export declare class BroadcastColumnsClear extends BeanBroadcastBase<TypeBroadcastColumnsClearJobData> implements IBroadcastExecute<TypeBroadcastColumnsClearJobData> {
+    execute(data: TypeBroadcastColumnsClearJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/broadcast.databaseClientReload.d.ts

@@ -0,0 +1,12 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastDatabaseClientReloadJobData {
+    clientName?: keyof IDatabaseClientRecord;
+    clientConfig?: ConfigDatabaseClient;
+    extraData?: any;
+}
+export declare class BroadcastDatabaseClientReload extends BeanBroadcastBase<TypeBroadcastDatabaseClientReloadJobData> implements IBroadcastExecute<TypeBroadcastDatabaseClientReloadJobData> {
+    execute(data: TypeBroadcastDatabaseClientReloadJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/event.clientNameReal.d.ts

@@ -0,0 +1,6 @@
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanEventBase } from 'vona-module-a-event';
+export type TypeEventClientNameRealData = keyof IDatabaseClientRecord;
+export type TypeEventClientNameRealResult = keyof IDatabaseClientRecord;
+export declare class EventClientNameReal extends BeanEventBase<TypeEventClientNameRealData, TypeEventClientNameRealResult> {
+}

package/dist/bean/event.columnsClear.d.ts

@@ -0,0 +1,9 @@
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanEventBase } from 'vona-module-a-event';
+export interface TypeEventColumnsClearData {
+    clientName: keyof IDatabaseClientRecord;
+    tableName?: string;
+}
+export type TypeEventColumnsClearResult = void;
+export declare class EventColumnsClear extends BeanEventBase<TypeEventColumnsClearData, TypeEventColumnsClearResult> {
+}

package/dist/bean/event.databaseClientReload.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanEventBase } from 'vona-module-a-event';
+export interface TypeEventDatabaseClientReloadData {
+    clientName: keyof IDatabaseClientRecord;
+    clientConfig?: ConfigDatabaseClient;
+    extraData?: any;
+}
+export type TypeEventDatabaseClientReloadResult = void;
+export declare class EventDatabaseClientReload extends BeanEventBase<TypeEventDatabaseClientReloadData, TypeEventDatabaseClientReloadResult> {
+}

package/dist/bean/schedule.softDeletionPrune.d.ts

@@ -0,0 +1,6 @@
+import type { IScheduleExecute } from 'vona-module-a-schedule';
+import { BeanBase } from 'vona';
+export declare class ScheduleSoftDeletionPrune extends BeanBase implements IScheduleExecute {
+    execute(): Promise<void>;
+    private _modulePrune;
+}

package/dist/common/buildWhere.d.ts

@@ -0,0 +1,4 @@
+import type { Knex } from 'knex';
+import type { TypeModelWhere } from '../types/modelWhere.ts';
+export declare function buildWhere<TRecord>(knex: Knex, builder: Knex.QueryBuilder, wheres: TypeModelWhere<TRecord>, having?: boolean): void;
+export declare function isAggrColumn(column: string): boolean;

package/dist/common/checkWhere.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './buildWhere.ts';
+export * from './checkWhere.ts';
+export * from './utils.ts';

package/dist/common/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelColumn, TypeModelColumns } from '../types/modelWhere.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+export declare function isRaw(raw: any): boolean;
+export declare function getTableOrTableAlias(table: string): string;
+export declare function getTargetColumnName(column: string): string;
+export declare function prepareColumns<TRecord>(columns?: TypeModelColumns<TRecord>): Array<TypeModelColumn<TRecord>> | undefined;
+export declare function prepareClassModel<ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(classType: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike): Constructable<ModelLike>;
+export declare function getClassEntityFromClassModel<T>(modelClass: Constructable<T>): Constructable<any>;

package/dist/config/config.d.ts

@@ -0,0 +1,72 @@
+import type { TypeBeanRecordGeneralSelectorKeys, VonaApplication } from 'vona';
+import type { IOnionOptionsMeta } from 'vona-module-a-onion';
+import type { TSummerCachePreset } from 'vona-module-a-summer';
+import type { IDatabaseClientDialectRecord } from '../types/database.ts';
+import type { TableIdentityType } from '../types/tableIdentity.ts';
+export type TypeDataBaseConfigDialects = Record<keyof IDatabaseClientDialectRecord, TypeBeanRecordGeneralSelectorKeys<'databaseDialect'>>;
+export declare function config(_app: VonaApplication): {
+    table: {
+        identityType: TableIdentityType;
+    };
+    model: {
+        disableDeleted: boolean;
+        disableInstance: boolean;
+        disableCreateTime: boolean;
+        disableUpdateTime: boolean;
+    };
+    softDeletionPrune: {
+        enable: boolean;
+        expired: number;
+    };
+    dialects: TypeDataBaseConfigDialects;
+    summer: {
+        enable: boolean;
+        meta: IOnionOptionsMeta;
+        presetDefault: TSummerCachePreset;
+        preset: {
+            redis: import("vona-module-a-summer").IDecoratorSummerCacheOptions;
+            redisWithIgnoreNull: {
+                ignoreNull: boolean;
+                preset?: TSummerCachePreset;
+                mode?: import("vona-module-a-summer").TSummerCacheMode;
+                mem?: {
+                    max?: number;
+                    ttl?: number;
+                    updateAgeOnGet?: boolean;
+                    updateAgeOnHas?: boolean;
+                    broadcastOnSet?: import("vona-module-a-cache").TypeBroadcastOnSet;
+                };
+                redis?: {
+                    ttl: number;
+                    updateAgeOnGet?: boolean;
+                    client?: keyof import("vona-module-a-redis").IRedisClientRecord;
+                };
+                enable?: boolean;
+                meta?: Omit<IOnionOptionsMeta, never> | undefined;
+            };
+            all: import("vona-module-a-summer").IDecoratorSummerCacheOptions;
+            allWithIgnoreNull: {
+                ignoreNull: boolean;
+                preset?: TSummerCachePreset;
+                mode?: import("vona-module-a-summer").TSummerCacheMode;
+                mem?: {
+                    max?: number;
+                    ttl?: number;
+                    updateAgeOnGet?: boolean;
+                    updateAgeOnHas?: boolean;
+                    broadcastOnSet?: import("vona-module-a-cache").TypeBroadcastOnSet;
+                };
+                redis?: {
+                    ttl: number;
+                    updateAgeOnGet?: boolean;
+                    client?: keyof import("vona-module-a-redis").IRedisClientRecord;
+                };
+                enable?: boolean;
+                meta?: Omit<IOnionOptionsMeta, never> | undefined;
+            };
+        };
+        redis: {
+            client: string;
+        };
+    };
+};

package/dist/config/errors.d.ts

@@ -0,0 +1,3 @@
+export declare enum Errors {
+    ShouldSpecifyTable = 1001
+}

package/dist/config/locale/en-us.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    TableIdentity: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    Deleted: string;
+    InstanceId: string;
+    ShouldSpecifyTable: string;
+};
+export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    TableIdentity: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    Deleted: string;
+    InstanceId: string;
+    ShouldSpecifyTable: string;
+};
+export default _default;

package/dist/extend/index.d.ts

@@ -0,0 +1,4 @@
+import type { VonaApplication } from 'vona';
+export * from './schemaBuilder.ts';
+export * from './tableBuilder.ts';
+export declare function ExtendKnex(app: VonaApplication): void;

package/dist/extend/schemaBuilder.d.ts

@@ -0,0 +1,13 @@
+import type { VonaApplication } from 'vona';
+import type { IFetchDatabasesResultItem, IFetchIndexesResultItem } from '../types/dialect.ts';
+export declare function ExtendSchemaBuilder(app: VonaApplication): void;
+declare module 'knex' {
+    namespace Knex {
+        interface SchemaBuilder {
+            fetchDatabases(databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+            createDatabase(databaseName: string): Promise<void>;
+            dropDatabase(databaseName: string): Promise<void>;
+            fetchIndexes(tableName: string): Promise<IFetchIndexesResultItem[]>;
+        }
+    }
+}

package/dist/extend/tableBuilder.d.ts

@@ -0,0 +1,22 @@
+import type { VonaApplication } from 'vona';
+export interface IBasicFieldsOptions {
+    id?: boolean;
+    timestamps?: boolean;
+    deleted?: boolean;
+    iid?: boolean;
+}
+export declare function ExtendTableBuilder(app: VonaApplication): void;
+declare module 'knex' {
+    namespace Knex {
+        interface TableBuilder {
+            basicFields(options?: IBasicFieldsOptions): Knex.TableBuilder;
+            basicFieldsSimple(options?: IBasicFieldsOptions): Knex.TableBuilder;
+            tableIdentity(columnName?: string): Knex.ColumnBuilder;
+            userId(columnName?: string): Knex.ColumnBuilder;
+            int0(columnName: string): Knex.ColumnBuilder;
+            int1(columnName: string): Knex.ColumnBuilder;
+            description(length?: number): Knex.ColumnBuilder;
+            content(useText?: boolean): Knex.ColumnBuilder;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import 'bignumber.js';
+export * from './.metadata/index.ts';
+export * from './bean/bean.model/bean.model_meta.ts';
+export * from './common/index.ts';
+export * from './extend/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';