@sqb/connect 4.9.0 → 4.10.0

package/esm/orm/commands/row-converter.d.ts

@@ -1,55 +0,0 @@
-import { Type } from 'ts-gems';
-import { DataType } from '@sqb/builder';
-import type { FieldInfoMap } from '../../client/field-info-map';
-import { SqbConnection } from '../../client/sqb-connection.js';
-import { ColumnTransformFunction } from '../orm.type.js';
-import type { Repository } from '../repository.class.js';
-import type { FindCommand } from './find.command.js';
-export interface ValueProperty {
-    fieldAlias: string;
-    dataType?: DataType;
-    parse?: ColumnTransformFunction;
-}
-export interface ObjectProperty {
-    converter: RowConverter;
-    type: Type;
-}
-export interface NestedProperty {
-    converter: RowConverter;
-    type: Type;
-    parentField: string;
-    keyField: string;
-    findCommand: FindCommand;
-    sort?: string[];
-    paramValues: any[];
-}
-export declare class RowConverter {
-    resultType: Type;
-    parent?: RowConverter | undefined;
-    private _properties;
-    private _propertyKeys?;
-    constructor(resultType: Type, parent?: RowConverter | undefined);
-    addValueProperty(args: {
-        name: string;
-        fieldAlias: string;
-        dataType?: DataType;
-        parse?: ColumnTransformFunction;
-    }): ValueProperty;
-    addObjectProperty(args: {
-        name: string;
-        type: Type;
-    }): ObjectProperty;
-    addNestedProperty(args: {
-        name: string;
-        type: Type;
-        findCommand: FindCommand;
-        parentField: string;
-        keyField: string;
-        sort?: string[];
-    }): NestedProperty;
-    get keys(): string[];
-    transform(connection: SqbConnection, fields: FieldInfoMap, rows: any, onTransform?: Repository.TransformRowFunction): Promise<any[]>;
-    private _rowToObject;
-    private _iterateForNested;
-    private _checkCircularDep;
-}

package/esm/orm/commands/update.command.d.ts

@@ -1,22 +0,0 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
-import { EntityMetadata } from '../model/entity-metadata.js';
-import { Repository } from '../repository.class.js';
-export type UpdateCommandArgs = {
-    entity: EntityMetadata;
-    connection: SqbConnection;
-    values: any;
-} & Repository.UpdateManyOptions;
-type UpdateCommandContext = {
-    entity: EntityMetadata;
-    queryParams: any;
-    queryValues: any;
-    queryFilter: any[];
-    colCount: number;
-};
-export declare class UpdateCommand {
-    protected constructor();
-    static execute(args: UpdateCommandArgs): Promise<number>;
-    protected static _prepareFilter(ctx: UpdateCommandContext, filter: any): Promise<void>;
-    protected static _prepareParams(ctx: UpdateCommandContext, entity: EntityMetadata, values: any, prefix?: string, suffix?: string): Promise<void>;
-}
-export {};

package/esm/orm/decorators/column.decorator.d.ts

@@ -1,4 +0,0 @@
-import { DataType } from '@sqb/builder';
-import { ColumnFieldOptions } from '../model/column-field-metadata.js';
-export declare function Column(type?: DataType): PropertyDecorator;
-export declare function Column(options?: ColumnFieldOptions): PropertyDecorator;

package/esm/orm/decorators/embedded.decorator.d.ts

@@ -1,3 +0,0 @@
-import { EmbeddedFieldOptions } from '../model/embedded-field-metadata.js';
-import { TypeThunk } from '../orm.type.js';
-export declare function Embedded(type?: TypeThunk, options?: EmbeddedFieldOptions): PropertyDecorator;

package/esm/orm/decorators/entity.decorator.d.ts

@@ -1,38 +0,0 @@
-import { Maybe, Type } from 'ts-gems';
-import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
-import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { AnyFieldMetadata, EntityMetadata, EntityOptions } from '../model/entity-metadata.js';
-import { IndexMetadata } from '../model/index-metadata.js';
-export declare function Entity(options?: EntityOptions | string): ClassDecorator;
-export declare namespace Entity {
-    const getMetadata: typeof EntityMetadata.get;
-    const getOwnMetadata: typeof EntityMetadata.getOwn;
-    function getField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AnyFieldMetadata>;
-    function getColumnField<T>(ctor: Type<T>, key: keyof T | string): Maybe<ColumnFieldMetadata>;
-    function getEmbeddedField<T>(ctor: Type<T>, key: keyof T | string): Maybe<EmbeddedFieldMetadata>;
-    function getAssociationField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AssociationFieldMetadata>;
-    function getColumnFieldByFieldName(ctor: Type, fieldName: string): Maybe<ColumnFieldMetadata>;
-    function find(ctor: Type, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
-    function getFieldNames(ctor: Type, filter?: (el: AnyFieldMetadata) => boolean): string[];
-    function getColumnFieldNames(ctor: Type): string[];
-    function getEmbeddedFieldNames(ctor: Type): string[];
-    function getAssociationFieldNames(ctor: Type): string[];
-    function getNonAssociationFieldNames(ctor: Type): string[];
-    function getInsertColumnNames(ctor: Type): string[];
-    function getUpdateColumnNames(ctor: Type): string[];
-    function getPrimaryIndex(ctor: Type): Maybe<IndexMetadata>;
-    function getPrimaryIndexColumns(ctor: Type): ColumnFieldMetadata[];
-    function mixin<A, B>(derivedCtor: Type<A>, baseB: Type<B>): Type<A & B>;
-    function mixin<A, B, C>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
-    function mixin<A, B, C, D>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
-    function mixin<A, B, C, D, E>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
-    function mixin<A, B, C, D, E, F>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
-    function Pick<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
-    function Omit<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;
-    function Union<A, B>(baseA: Type<A>, baseB: Type<B>): Type<A & B>;
-    function Union<A, B, C>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
-    function Union<A, B, C, D>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
-    function Union<A, B, C, D, E>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
-    function Union<A, B, C, D, E, F>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
-}

package/esm/orm/decorators/events.decorator.d.ts

@@ -1,6 +0,0 @@
-export declare function BeforeInsert(): PropertyDecorator;
-export declare function BeforeUpdate(): PropertyDecorator;
-export declare function BeforeDestroy(): PropertyDecorator;
-export declare function AfterInsert(): PropertyDecorator;
-export declare function AfterUpdate(): PropertyDecorator;
-export declare function AfterDestroy(): PropertyDecorator;

package/esm/orm/decorators/foreignkey.decorator.d.ts

@@ -1,2 +0,0 @@
-import { TypeThunk } from '../orm.type.js';
-export declare function ForeignKey(type: TypeThunk, targetKey?: string): PropertyDecorator;

package/esm/orm/decorators/index.decorator.d.ts

@@ -1,3 +0,0 @@
-import { IndexMetadata } from '../model/index-metadata.js';
-export declare function Index(fields: string | string[], options?: Omit<IndexMetadata, 'columns'>): ClassDecorator;
-export declare function Index(options?: Omit<IndexMetadata, 'columns'>): PropertyDecorator;

package/esm/orm/decorators/link.decorator.d.ts

@@ -1,13 +0,0 @@
-import { AssociationFieldOptions } from '../model/association-field-metadata.js';
-import { TypeThunk } from '../orm.type.js';
-type LinkArgs<T> = {
-    sourceKey?: string;
-    targetKey?: keyof T;
-    where?: object | object[];
-};
-type LinkPropertyDecorator = PropertyDecorator & {
-    toOne<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
-    toMany<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
-};
-export declare function Link(options?: AssociationFieldOptions): LinkPropertyDecorator;
-export {};

package/esm/orm/decorators/primarykey.decorator.d.ts

@@ -1,3 +0,0 @@
-import { IndexMetadata } from '../model/index-metadata.js';
-export declare function PrimaryKey(fields: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): ClassDecorator;
-export declare function PrimaryKey(options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): PropertyDecorator;

package/esm/orm/decorators/transform.decorator.d.ts

@@ -1,3 +0,0 @@
-import { ColumnTransformFunction } from '../orm.type.js';
-export declare function Parse(fn: ColumnTransformFunction): PropertyDecorator;
-export declare function Serialize(fn: ColumnTransformFunction): PropertyDecorator;

package/esm/orm/model/association-field-metadata.d.ts

@@ -1,12 +0,0 @@
-import { AssociationNode } from './association-node.js';
-import { EntityMetadata } from './entity-metadata.js';
-import { FieldMetadata } from './field-metadata.js';
-export type AssociationFieldOptions = Partial<Omit<AssociationFieldMetadata, 'entity' | 'name' | 'kind' | 'association'>>;
-export interface AssociationFieldMetadata extends FieldMetadata {
-    readonly kind: 'association';
-    readonly association: AssociationNode;
-}
-export declare namespace AssociationFieldMetadata {
-    function create(entity: EntityMetadata, name: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
-    function assign(target: AssociationFieldMetadata, options: AssociationFieldOptions): void;
-}

package/esm/orm/model/association-node.d.ts

@@ -1,9 +0,0 @@
-import { Association } from './association.js';
-export declare class AssociationNode extends Association {
-    prior?: AssociationNode;
-    next?: AssociationNode;
-    conditions?: any[];
-    getFirst(): AssociationNode;
-    getLast(): AssociationNode;
-    returnsMany(): boolean;
-}

package/esm/orm/model/association.d.ts

@@ -1,27 +0,0 @@
-import { AssociationSettings, TypeThunk } from '../orm.type.js';
-import { ColumnFieldMetadata } from './column-field-metadata.js';
-import { EntityMetadata } from './entity-metadata.js';
-export declare class Association {
-    private _resolved?;
-    private _source?;
-    private _target?;
-    private _sourceKey?;
-    private _targetKey?;
-    private _sourceProperty?;
-    private _targetProperty?;
-    name: string;
-    readonly source: TypeThunk;
-    readonly target: TypeThunk;
-    readonly sourceKey?: string;
-    readonly targetKey?: string;
-    readonly many: boolean;
-    constructor(name: string, args: AssociationSettings);
-    resolveSource(): Promise<EntityMetadata>;
-    resolveTarget(): Promise<EntityMetadata>;
-    resolveSourceKey(): Promise<string>;
-    resolveSourceProperty(): Promise<ColumnFieldMetadata>;
-    resolveTargetKey(): Promise<string>;
-    resolveTargetProperty(): Promise<ColumnFieldMetadata>;
-    returnsMany(): boolean;
-    protected _resolveKeys(): Promise<void>;
-}

package/esm/orm/model/column-field-metadata.d.ts

@@ -1,75 +0,0 @@
-import { DataType } from '@sqb/builder';
-import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type.js';
-import type { EntityMetadata } from './entity-metadata.js';
-import { FieldMetadata } from './field-metadata.js';
-export type ColumnFieldOptions = Partial<Omit<ColumnFieldMetadata, 'entity' | 'name' | 'kind'>>;
-export interface ColumnFieldMetadata extends FieldMetadata {
-    readonly kind: 'column';
-    /**
-     Name of table field
-     */
-    fieldName: string;
-    /**
-     JS type. String, Boolean, Person etc
-     */
-    type?: Function;
-    /**
-     * Column data type
-     */
-    dataType?: DataType;
-    /**
-     * Field comment
-     */
-    comment?: string;
-    /**
-     * Column's default value
-     */
-    default?: FieldValue | DefaultValueGetter;
-    /**
-     * Indicates if column data is an array
-     */
-    isArray?: boolean;
-    /**
-     * Indicates enum values
-     */
-    enum?: EnumValue;
-    /**
-     * Character or byte length of column
-     */
-    length?: number;
-    /**
-     * The precision for a decimal field
-     */
-    precision?: number;
-    /**
-     * The scale for a decimal field
-     */
-    scale?: number;
-    /**
-     * Fields's collation.
-     */
-    collation?: string;
-    /**
-     * Indicates auto generation strategy
-     */
-    autoGenerated?: ColumnAutoGenerationStrategy;
-    /**
-     * Indicates if column value can be null
-     */
-    notNull?: boolean;
-    /**
-     * Indicates if column value is used in update queries
-     */
-    noUpdate?: boolean;
-    /**
-     * Indicates if column value is used in insert queries
-     */
-    noInsert?: boolean;
-    parse?: ColumnTransformFunction;
-    serialize?: ColumnTransformFunction;
-}
-export declare namespace ColumnFieldMetadata {
-    function create(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
-    function assign(target: ColumnFieldMetadata, options: ColumnFieldOptions): void;
-    function checkEnumValue(col: ColumnFieldMetadata, v: FieldValue): void;
-}

package/esm/orm/model/embedded-field-metadata.d.ts

@@ -1,14 +0,0 @@
-import { TypeThunk } from '../orm.type.js';
-import type { EntityMetadata } from './entity-metadata.js';
-import { FieldMetadata } from './field-metadata.js';
-export type EmbeddedFieldOptions = Partial<Omit<EmbeddedFieldMetadata, 'entity' | 'name' | 'kind' | 'type'>>;
-export interface EmbeddedFieldMetadata extends FieldMetadata {
-    readonly kind: 'object';
-    type: TypeThunk;
-    fieldNamePrefix?: string;
-    fieldNameSuffix?: string;
-}
-export declare namespace EmbeddedFieldMetadata {
-    function create(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
-    function resolveType(meta: EmbeddedFieldMetadata): Promise<EntityMetadata>;
-}

package/esm/orm/model/entity-metadata.d.ts

@@ -1,50 +0,0 @@
-import { Maybe, Type } from 'ts-gems';
-import { Ctor, TypeThunk } from '../orm.type.js';
-import { Association } from './association.js';
-import { AssociationFieldMetadata, AssociationFieldOptions } from './association-field-metadata.js';
-import { AssociationNode } from './association-node.js';
-import { ColumnFieldMetadata, ColumnFieldOptions } from './column-field-metadata.js';
-import { EmbeddedFieldMetadata, EmbeddedFieldOptions } from './embedded-field-metadata.js';
-import { IndexMetadata } from './index-metadata.js';
-export type AnyFieldMetadata = ColumnFieldMetadata | EmbeddedFieldMetadata | AssociationFieldMetadata;
-export type EntityOptions = Partial<Pick<EntityMetadata, 'name' | 'schema' | 'comment' | 'tableName'>>;
-export interface EntityMetadata {
-    readonly ctor: Type;
-    readonly name: string;
-    tableName?: string;
-    schema?: string;
-    comment?: string;
-    fields: Record<string, AnyFieldMetadata>;
-    indexes: IndexMetadata[];
-    foreignKeys: Association[];
-    eventListeners: Record<string, Function[]>;
-}
-export declare namespace EntityMetadata {
-    function define(ctor: Ctor): EntityMetadata;
-    function get(ctor: Ctor): Maybe<EntityMetadata>;
-    function getOwn(ctor: Ctor): Maybe<EntityMetadata>;
-    function getField(entity: EntityMetadata, fieldName: string): Maybe<AnyFieldMetadata>;
-    function getColumnField(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
-    function getEmbeddedField(entity: EntityMetadata, fieldName: string): Maybe<EmbeddedFieldMetadata>;
-    function getAssociationField(entity: EntityMetadata, fieldName: string): Maybe<AssociationFieldMetadata>;
-    function findField(entity: EntityMetadata, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
-    function getColumnFieldByFieldName(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
-    function getFieldNames(entity: EntityMetadata, filter?: (el: AnyFieldMetadata) => boolean): string[];
-    function getColumnFieldNames(entity: EntityMetadata): string[];
-    function getEmbeddedFieldNames(entity: EntityMetadata): string[];
-    function getAssociationFieldNames(entity: EntityMetadata): string[];
-    function getNonAssociationFieldNames(entity: EntityMetadata): string[];
-    function getInsertColumnNames(entity: EntityMetadata): string[];
-    function getUpdateColumnNames(entity: EntityMetadata): string[];
-    function getPrimaryIndex(entity: EntityMetadata): Maybe<IndexMetadata>;
-    function getPrimaryIndexColumns(entity: EntityMetadata): ColumnFieldMetadata[];
-    function getForeignKeyFor(src: EntityMetadata, trg: EntityMetadata): Promise<Maybe<Association>>;
-    function addIndex(entity: EntityMetadata, index: IndexMetadata): void;
-    function addForeignKey(entity: EntityMetadata, propertyKey: string, target: TypeThunk, targetKey?: string): void;
-    function addEventListener(entity: EntityMetadata, event: string, fn: Function): void;
-    function defineColumnField(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
-    function defineEmbeddedField(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
-    function defineAssociationField(entity: EntityMetadata, propertyKey: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
-    function setPrimaryKeys(entity: EntityMetadata, column: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): void;
-    function mixin(derived: EntityMetadata, base: EntityMetadata, filter?: (n: string) => boolean): void;
-}

package/esm/orm/model/field-metadata.d.ts

@@ -1,16 +0,0 @@
-import type { FieldKind } from '../orm.type.js';
-import type { EntityMetadata } from './entity-metadata.js';
-export interface FieldMetadata {
-    readonly entity: EntityMetadata;
-    readonly name: string;
-    readonly kind: FieldKind;
-    /**
-     * Indicates whether or not to hide this field by default when making queries.
-     */
-    hidden?: boolean;
-    /**
-     * Indicates whether or not to include this field by default when making queries.
-     * If this set to "true" the field must be requested using "include" or "pick" option.
-     */
-    exclusive?: boolean;
-}

package/esm/orm/model/index-metadata.d.ts

@@ -1,18 +0,0 @@
-export interface IndexMetadata {
-    /**
-     *  Columns of the index
-     */
-    columns: string[];
-    /**
-     *  Name of the index
-     */
-    name?: string;
-    /**
-     * Specifies if index is unique
-     */
-    unique?: boolean;
-    /**
-     * Specifies if index is primary
-     */
-    primary?: boolean;
-}

package/esm/orm/model/link-chain.d.ts

@@ -1,13 +0,0 @@
-import { Type } from 'ts-gems';
-import { TypeResolver, TypeThunk } from '../orm.type.js';
-import { AssociationNode } from './association-node.js';
-export declare class LinkChain<T> {
-    target: TypeThunk<T>;
-    first: AssociationNode;
-    current: AssociationNode;
-    constructor(target: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string, many?: boolean);
-    where(conditions: object | object[]): this;
-    linkToOne<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
-    linkToMany<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
-    private _newNode;
-}

package/esm/orm/orm.const.d.ts

@@ -1,2 +0,0 @@
-export declare const ENTITY_METADATA_KEY: unique symbol;
-export declare const REPOSITORY_KEY: unique symbol;

package/esm/orm/orm.type.d.ts

@@ -1,20 +0,0 @@
-import { Type } from 'ts-gems';
-export type Ctor = Type | Function;
-export type FieldKind = 'column' | 'object' | 'association';
-/**
- * Indicates auto generation strategy
- */
-export type ColumnAutoGenerationStrategy = 'increment' | 'uuid' | 'rowid' | 'timestamp' | 'custom';
-export type ColumnTransformFunction = (value: any, name: string) => any;
-export type TypeResolver<T> = () => Type<T> | Promise<Type<T>>;
-export type TypeThunk<T = any> = Type<T> | TypeResolver<T>;
-export type EnumValue = (FieldValue)[] | Object;
-export type FieldValue = string | number | boolean | Date | null;
-export type DefaultValueGetter = (obj?: any) => FieldValue | undefined;
-export interface AssociationSettings {
-    source: TypeThunk;
-    target: TypeThunk;
-    sourceKey?: string;
-    targetKey?: string;
-    many?: boolean;
-}

package/esm/orm/repository.class.d.ts

@@ -1,140 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { FieldInfoMap } from '../client/field-info-map.js';
-import { SqbClient } from '../client/sqb-client.js';
-import { SqbConnection } from '../client/sqb-connection.js';
-import { QueryRequest, TransactionFunction } from '../client/types.js';
-import { EntityInput, EntityOutput } from '../types.js';
-import { EntityMetadata } from './model/entity-metadata.js';
-interface Projection {
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-}
-interface Filtering {
-    filter?: any;
-    params?: any;
-}
-export declare namespace Repository {
-    type TransformRowFunction = (fields: FieldInfoMap, row: object, obj: object) => void;
-    interface CommandOptions {
-        connection?: SqbConnection;
-    }
-    interface CreateOptions extends CommandOptions, Projection {
-    }
-    interface CountOptions extends CommandOptions, Filtering {
-    }
-    interface ExistsOptions extends CommandOptions, Filtering {
-    }
-    interface DeleteOptions extends CommandOptions, Filtering {
-    }
-    interface DeleteManyOptions extends CommandOptions, Filtering {
-    }
-    interface FindOptions extends CommandOptions, Projection, Filtering {
-    }
-    interface FindOneOptions extends CommandOptions, Projection, Filtering {
-        sort?: string[];
-        offset?: number;
-    }
-    interface FindManyOptions extends FindOneOptions {
-        limit?: number;
-        distinct?: boolean;
-        maxEagerFetch?: number;
-        maxSubQueries?: number;
-        onTransformRow?: TransformRowFunction;
-    }
-    interface UpdateOptions extends CommandOptions, Projection, Filtering {
-    }
-    interface UpdateManyOptions extends CommandOptions, Filtering {
-    }
-    /**
-     * @deprecated
-     */
-    type FindAllOptions = FindManyOptions;
-    /**
-     * @deprecated
-     */
-    type DestroyOptions = DeleteOptions;
-    /**
-     * @deprecated
-     */
-    type UpdateAllOptions = UpdateManyOptions;
-}
-interface RepositoryEvents {
-    execute: (request: QueryRequest) => void;
-    error: (error: Error) => void;
-    acquire: (connection: SqbConnection) => Promise<void>;
-}
-declare const Repository_base: Type<import("strict-typed-events").TypedEventEmitter<any, RepositoryEvents, RepositoryEvents>>;
-export declare class Repository<T> extends Repository_base {
-    private readonly _executor;
-    private readonly _entity;
-    private readonly _schema?;
-    constructor(entityDef: EntityMetadata, executor: SqbClient | SqbConnection, schema?: string);
-    get entity(): EntityMetadata;
-    get type(): Type<T>;
-    create(values: EntityInput<T>, options?: Repository.CreateOptions): Promise<EntityOutput<T>>;
-    createOnly(values: EntityInput<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
-    exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
-    count(options?: Repository.CountOptions): Promise<number>;
-    find(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<EntityOutput<T> | undefined>;
-    findOne(options?: Repository.FindOneOptions): Promise<EntityOutput<T> | undefined>;
-    findMany(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
-    delete(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
-    deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
-    update(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<EntityOutput<T> | undefined>;
-    updateOnly(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: StrictOmit<Repository.UpdateOptions, keyof Projection>): Promise<boolean>;
-    updateMany(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
-    /**
-     *
-     * @deprecated
-     */
-    destroy(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
-    /**
-     *
-     * @deprecated
-     */
-    destroyAll(options?: Repository.DeleteManyOptions): Promise<number>;
-    /**
-     *
-     * @deprecated
-     */
-    findAll(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
-    /**
-     *
-     * @deprecated
-     */
-    updateAll(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
-    protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
-    protected _create(values: EntityInput<T>, options: Repository.CreateOptions & {
-        connection: SqbConnection;
-        returning?: boolean;
-    }): Promise<any>;
-    protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
-        connection: SqbConnection;
-    }): Promise<boolean>;
-    protected _count(options: Repository.CountOptions & {
-        connection: SqbConnection;
-    }): Promise<number>;
-    protected _findMany(options: Repository.FindManyOptions & {
-        connection: SqbConnection;
-    }): Promise<EntityOutput<T>[]>;
-    protected _findOne(options: Repository.FindOneOptions & {
-        connection: SqbConnection;
-    }): Promise<EntityOutput<T> | undefined>;
-    protected _find(keyValue: any | Record<string, any>, options: Repository.FindOptions & {
-        connection: SqbConnection;
-    }): Promise<EntityOutput<T> | undefined>;
-    protected _delete(keyValue: any | Record<string, any>, options: Repository.DeleteOptions & {
-        connection: SqbConnection;
-    }): Promise<boolean>;
-    protected _deleteMany(options: Repository.DeleteManyOptions & {
-        connection: SqbConnection;
-    }): Promise<number>;
-    protected _update(keyValue: any | Record<string, any>, values: EntityInput<T>, options: Repository.UpdateOptions & {
-        connection: SqbConnection;
-    }): Promise<Record<string, any> | undefined>;
-    protected _updateMany(values: EntityInput<T>, options: Repository.UpdateManyOptions & {
-        connection: SqbConnection;
-    }): Promise<number>;
-}
-export {};

package/esm/orm/util/apply-mixins.d.ts

@@ -1 +0,0 @@
-export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;

package/esm/orm/util/extract-keyvalues.d.ts

@@ -1,2 +0,0 @@
-import { EntityMetadata } from '../model/entity-metadata.js';
-export declare function extractKeyValues<T>(entityDef: EntityMetadata, valueOrInstance: any | Record<string, any> | T, keepOther?: boolean): Record<string, any>;

package/esm/orm/util/orm.helper.d.ts

@@ -1,13 +0,0 @@
-import { Type } from 'ts-gems';
-import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
-import type { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import type { EntityMetadata } from '../model/entity-metadata.js';
-import type { TypeThunk } from '../orm.type.js';
-export declare function isClass(fn: any): fn is Type;
-export declare function isEntityClass(fn: any): fn is Type;
-export declare function isColumnField(f: any): f is ColumnFieldMetadata;
-export declare const isEmbeddedField: (f: any) => f is EmbeddedFieldMetadata;
-export declare const isAssociationField: (f: any) => f is AssociationFieldMetadata;
-export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
-export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityMetadata | undefined>;

package/esm/orm/util/serialize-field.d.ts

@@ -1,2 +0,0 @@
-import { FieldMetadata } from '../model/field-metadata.js';
-export declare function serializeColumn(col: FieldMetadata, v: any): any;

package/esm/types.d.ts

@@ -1,12 +0,0 @@
-import { Builtin, DeepPickWritable } from 'ts-gems';
-export type EntityInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
-export type EntityOutput<T> = DeepPartial<T>;
-export type DeepNullablePartial<T> = _DeepNullablePartial<T>;
-type _DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
-    [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
-};
-export type DeepPartial<T> = _DeepPartial<T>;
-type _DeepPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepPartial<U>> : T extends (infer U)[] ? DeepPartial<U>[] : {
-    [P in keyof T]?: DeepPartial<Exclude<T[P], undefined>>;
-};
-export {};