bigal 12.1.5 → 13.0.0-beta1

package/dist/index.d.mts

@@ -0,0 +1,892 @@
+import { Pool } from 'postgres-pool';
+
+interface ClassLike {
+    /**
+     * Returns the name of the function. Function names are read-only and can not be changed.
+     */
+    readonly constructor: {
+        readonly name: string;
+    };
+}
+
+/**
+ * Removes all entity collection properties. To be used as a re-map key function
+ */
+type ExcludeEntityCollections<T, K extends PropertyKey> = T extends NotEntityBrand[] | undefined ? K : T extends Entity[] | undefined ? never : K;
+
+/**
+ * Removes all functions and entity collection properties. To be used as a re-map key function
+ */
+type ExcludeFunctions<T, K extends PropertyKey> = T extends Function ? never : K;
+
+/**
+ * Changes all Entity value properties to Primitive (string|number) | Pick<Entity, 'id'>
+ */
+type CreateUpdateParams<T extends Entity> = {
+    [K in keyof T as ExcludeEntityCollections<NonNullable<T[K]>, ExcludeFunctions<T[K], K>>]?: T[K] extends NotEntityBrand | undefined ? T[K] : Extract<T[K], Entity> extends undefined ? T[K] : Exclude<T[K], Entity> | Pick<Extract<T[K], Entity>, 'id'>;
+};
+
+type EntityPrimitiveOrId<T> = T extends [] ? T extends (infer U)[] ? EntityPrimitiveOrId<U>[] : T : Extract<NonNullable<T>, Entity> extends undefined ? T : Exclude<NonNullable<T>, Entity> | Pick<Extract<NonNullable<T>, Entity>, 'id'>;
+
+type GetValueType<T, TValueType> = T extends TValueType[] ? T extends (infer U)[] ? Extract<U, TValueType> : never : T extends TValueType ? T : never;
+
+/**
+ * Returns the key name if the property type is a function
+ */
+type IncludeFunctions<T, K extends PropertyKey> = T extends Function ? K : never;
+
+type IsValueOfType<T, K extends PropertyKey, TValueType> = T extends TValueType | TValueType[] | undefined ? K : never;
+
+/**
+ * Removes all entity collection properties
+ */
+type OmitEntityCollections<T> = {
+    [K in keyof T as ExcludeEntityCollections<T[K], K>]: T[K];
+};
+
+/**
+ * Removes all functions
+ */
+type OmitFunctions<T> = {
+    [K in keyof T as ExcludeFunctions<T[K], K>]: T[K];
+};
+
+type PickAsType<T, K extends keyof T, TValue> = {
+    [P in K]: Extract<T[P], TValue>;
+};
+
+type PickByValueType<T, TValueType> = {
+    [K in keyof T as IsValueOfType<T[K], K, TValueType>]: GetValueType<T[K], TValueType>;
+};
+
+type PickFunctions<T> = {
+    [K in keyof T as IncludeFunctions<T[K], K>]: T[K];
+};
+
+/**
+ * Changes all properties with Entity values to Primitive (string|number). Removes any properties that with values
+ * of Entity arrays
+ */
+type QueryResult<T extends Entity> = Extract<{
+    [K in keyof T as ExcludeEntityCollections<NonNullable<T[K]>, K>]: T[K] extends NotEntityBrand | undefined ? T[K] : Exclude<T[K], Entity>;
+}, T>;
+
+/**
+ * Removes primitives from specified properties and make non-optional. Allow singular Entity properties to be null.
+ */
+type Populated<T extends Entity, K extends keyof T, TPropertyType extends Entity, TPropertyKeys extends keyof TPropertyType> = {
+    [P in K]-?: Extract<T[P], Entity | Entity[]> extends Entity ? undefined extends T[P] ? QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | 'id'>> | null : QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | 'id'>> : QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | 'id'>>[];
+};
+
+/**
+ * Allows a QueryResult type with specific populated properties
+ */
+type QueryResultPopulated<T extends Entity, K extends keyof T> = Omit<QueryResult<T>, K> & {
+    [P in K]-?: Extract<T[P], Entity | Entity[]> extends Entity ? undefined extends T[P] ? QueryResult<GetValueType<T[P], Entity>> | null : QueryResult<GetValueType<T[P], Entity>> : QueryResult<GetValueType<T[P], Entity>>[];
+};
+
+/**
+ * Allows a QueryResult type with specific properties optionally populated. If the property is populated, only the id property is needed
+ */
+type QueryResultOptionalPopulated<T extends Entity, K extends keyof T> = Omit<QueryResult<T>, K> & {
+    [P in K]-?: T[P] extends [] ? undefined extends T[P] ? EntityPrimitiveOrId<T[P]> | null : EntityPrimitiveOrId<T[P]> : EntityPrimitiveOrId<T[P]>;
+};
+
+type EntityFieldValue = boolean[] | Date | number[] | Record<string, unknown> | string[] | boolean | number | string | unknown | null;
+declare abstract class Entity {
+    abstract id: unknown;
+    static beforeCreate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+    static beforeUpdate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+}
+interface NotEntityBrand {
+    _notEntityBrand: void;
+}
+type NotEntity<T> = NotEntityBrand & T;
+interface EntityStatic<T extends Entity> {
+    beforeCreate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+    beforeUpdate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+    new (): T;
+}
+
+interface ColumnBaseMetadataOptions {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+    /**
+     * Indicates if column is inserted by default. Default is true
+     */
+    insert?: boolean;
+    /**
+     * Indicates if column value is updated by "save" operation. Default is true
+     */
+    update?: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate?: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version?: boolean;
+}
+declare abstract class ColumnBaseMetadata {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required: boolean;
+    /**
+     * Indicates if column is inserted by default. Default is true
+     */
+    insert: boolean;
+    /**
+     * Indicates if column value is updated by "save" operation. Default is true
+     */
+    update: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version: boolean;
+    protected constructor({ target, name, propertyName, required, insert, update, primary, createDate, updateDate, version, }: ColumnBaseMetadataOptions);
+}
+
+interface ColumnCollectionMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Type of the items in the collection
+     */
+    collection: string | (() => string);
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    through?: string | (() => string);
+}
+declare class ColumnCollectionMetadata extends ColumnBaseMetadata {
+    private _collectionString?;
+    private _collectionFn?;
+    private _throughString?;
+    private _throughFn?;
+    /**
+     * Type of the items in the collection
+     */
+    get collection(): string;
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    get through(): string | undefined;
+    constructor({ target, //
+    name, propertyName, required, insert, update, primary, createDate, updateDate, version, collection, via, through, }: ColumnCollectionMetadataOptions);
+}
+
+interface ColumnModelMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Name of the model represented by this column id
+     */
+    model: string | (() => string);
+}
+declare class ColumnModelMetadata extends ColumnBaseMetadata {
+    private _modelString?;
+    private _modelFn?;
+    /**
+     * Name of the model represented by this column id
+     */
+    get model(): string;
+    constructor({ target, //
+    name, propertyName, required, insert, update, primary, createDate, updateDate, version, model, }: ColumnModelMetadataOptions);
+}
+
+interface ColumnTypeMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Type of sql column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+}
+declare class ColumnTypeMetadata extends ColumnBaseMetadata {
+    /**
+     * Type of the column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+    constructor(options: ColumnTypeMetadataOptions);
+}
+
+type ColumnMetadata = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+
+interface ColumnModifierMetadata {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name?: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate?: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version?: boolean;
+    /**
+     * Type of sql column
+     */
+    type?: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Name of the model represented by this column id
+     */
+    model?: string | (() => string);
+}
+
+type Column = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+type ColumnByStringId = Record<string, Column>;
+interface ModelMetadataOptions<T extends Entity> {
+    name: string;
+    type: EntityStatic<T>;
+    connection?: string;
+    tableName?: string;
+    readonly?: boolean;
+}
+declare class ModelMetadata<T extends Entity> {
+    private _columns;
+    private _primaryKeyColumn;
+    private _createDateColumns;
+    private _updateDateColumns;
+    private _versionDateColumns;
+    set columns(columns: readonly Column[]);
+    get columns(): readonly Column[];
+    get primaryKeyColumn(): Column | undefined;
+    get createDateColumns(): readonly Column[];
+    get updateDateColumns(): readonly Column[];
+    get versionColumns(): readonly Column[];
+    name: string;
+    type: EntityStatic<T>;
+    connection?: string;
+    tableName: string;
+    readonly: boolean;
+    columnsByColumnName: ColumnByStringId;
+    columnsByPropertyName: ColumnByStringId;
+    constructor({ name, //
+    type, connection, tableName, readonly, }: ModelMetadataOptions<T>);
+}
+
+/**
+ * This represents an object to store all of the decorator data. Since there can be multiple decorators per
+ * class/property, things will be reconciled when entities are initialized
+ */
+declare class MetadataStorage<T extends Entity> {
+    readonly models: ModelMetadata<T>[];
+    readonly columns: ColumnMetadata[];
+    readonly columnModifiers: ColumnModifierMetadata[];
+}
+
+declare function getMetadataStorage<T extends Entity>(): MetadataStorage<T>;
+
+type ExcludeUndefined<T> = Exclude<T, undefined>;
+type LiteralValues<TValue> = (TValue | null)[] | TValue | null;
+type WhereClauseValue<TValue> = TValue extends NotEntityBrand | undefined ? Exclude<TValue, NotEntityBrand | undefined> : Extract<TValue, Entity> extends undefined ? LiteralValues<ExcludeUndefined<TValue>> : (ExcludeUndefined<Exclude<TValue, Entity>> | null)[] | (Pick<Extract<ExcludeUndefined<TValue>, Entity>, 'id'> | null)[] | ExcludeUndefined<Exclude<TValue, Entity>> | Pick<Extract<ExcludeUndefined<TValue>, Entity>, 'id'> | null;
+type StringConstraint<TValue extends string> = {
+    [P in 'contains' | 'endsWith' | 'like' | 'startsWith']?: LiteralValues<ExcludeUndefined<TValue>>;
+};
+type NumberOrDateConstraint<TValue extends Date | number> = {
+    [P in '<' | '<=' | '>' | '>=']?: LiteralValues<ExcludeUndefined<TValue>>;
+};
+type NegatableConstraint<TValue> = TValue | {
+    '!': TValue;
+};
+type WhereQueryStatement<TValue> = [TValue] extends [string] ? NegatableConstraint<StringConstraint<TValue> | WhereClauseValue<TValue>> : TValue extends string ? NegatableConstraint<StringConstraint<TValue> | WhereClauseValue<TValue>> : TValue extends Date | number ? NegatableConstraint<NumberOrDateConstraint<TValue> | WhereClauseValue<TValue>> : NegatableConstraint<WhereClauseValue<TValue>>;
+type WhereQuery<T extends Entity> = {
+    [K in keyof T as ExcludeEntityCollections<T[K], ExcludeFunctions<T[K], K>>]?: K extends 'id' ? WhereQueryStatement<T | T[K]> : T[K] extends (infer U)[] | undefined ? WhereQueryStatement<ExcludeUndefined<U>> : NegatableConstraint<LiteralValues<ExcludeUndefined<T[K]>>> | WhereQueryStatement<ExcludeUndefined<T[K]>>;
+} & {
+    or?: WhereQuery<T>[];
+};
+
+interface CountResult<TEntity extends Entity> extends PromiseLike<number> {
+    where(args: WhereQuery<TEntity>): CountResult<TEntity> | number;
+}
+
+interface DoNotReturnRecords {
+    returnRecords: false;
+}
+
+interface ReturnSelect$1<T extends Entity, K extends keyof OmitFunctions<OmitEntityCollections<T>> = keyof OmitFunctions<OmitEntityCollections<T>>> {
+    returnSelect: (K & string)[];
+}
+
+type CreateUpdateOptions<T extends Entity> = DoNotReturnRecords | ReturnSelect$1<T>;
+
+interface ReturnSelect<T extends Entity, K extends keyof T> {
+    returnSelect: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+    returnRecords?: true;
+}
+interface ReturnRecords<T extends Entity, K extends keyof T> {
+    returnRecords: true;
+    returnSelect?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+}
+type DeleteOptions<T extends Entity, K extends keyof T = keyof T> = ReturnRecords<T, K> | ReturnSelect<T, K>;
+
+interface DestroyResult<TEntity extends Entity, TReturn> extends PromiseLike<TReturn> {
+    where(args: WhereQuery<TEntity>): DestroyResult<TEntity, TReturn>;
+}
+
+type SortString<T extends Entity> = `${string & keyof OmitFunctions<OmitEntityCollections<T>>} ASC` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} asc` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} DESC` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} desc` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>}`;
+type ValidateMultipleSorts<T extends Entity, TNextSortPart extends string, TPreviouslyValidatedSortString extends string, TSortString extends string> = TNextSortPart extends `, ${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends '' ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TNextSortPart extends `${infer TValidatedSortPart}${TRestSortPart}` ? `${TPreviouslyValidatedSortString}${TValidatedSortPart}` : never, TSortString> : `${TPreviouslyValidatedSortString}, ${SortString<T>}`;
+type MultipleSortString<T extends Entity, TSortString extends string = string> = TSortString extends `${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends '' ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TSortString extends `${infer TPreviouslyValidatedSortString}${TRestSortPart}` ? TPreviouslyValidatedSortString : never, TSortString> : SortString<T>;
+type SortObjectValue = -1 | 'asc' | 'desc' | 1;
+type SortObject<T extends Entity> = {
+    [K in keyof T as ExcludeFunctions<OmitEntityCollections<T>, K>]?: SortObjectValue;
+};
+type Sort<T extends Entity> = MultipleSortString<T> | SortObject<T>;
+interface OrderBy<T extends Entity> {
+    propertyName: string & keyof OmitFunctions<OmitEntityCollections<T>>;
+    descending?: boolean;
+}
+
+interface FindOneArgs<T extends Entity, K extends keyof T = string & keyof OmitFunctions<OmitEntityCollections<T>> & keyof T> {
+    select?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+    where?: WhereQuery<T>;
+    sort?: Sort<T>;
+    pool?: Pool;
+}
+
+interface FindArgs<T extends Entity, K extends keyof T = keyof T> extends FindOneArgs<T, K> {
+    skip?: number;
+    limit?: number;
+}
+
+interface PopulateArgs<T extends Entity, K extends keyof T> {
+    where?: WhereQuery<T>;
+    select?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+    sort?: Sort<T>;
+    skip?: number;
+    limit?: number;
+    pool?: Pool;
+}
+
+interface FindOneResult<T extends Entity, TReturn> extends PromiseLike<TReturn | null> {
+    where(args: WhereQuery<T>): FindOneResult<T, TReturn>;
+    populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindOneResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>>;
+    sort(value?: Sort<T>): FindOneResult<T, TReturn>;
+    UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindOneResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>>;
+    UNSAFE_withFieldValue<TProperty extends string & keyof T, TValue extends T[TProperty]>(propertyName: TProperty, value: TValue): FindOneResult<T, Omit<TReturn, TProperty> & PickAsType<T, TProperty, TValue>>;
+}
+
+interface PaginateOptions {
+    limit: number;
+    page: number;
+}
+
+interface FindResult<T extends Entity, TReturn> extends PromiseLike<TReturn[]> {
+    where(args: WhereQuery<T>): FindResult<T, TReturn>;
+    populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>>;
+    sort(value?: Sort<T>): FindResult<T, TReturn>;
+    limit(value: number): FindResult<T, TReturn>;
+    skip(value: number): FindResult<T, TReturn>;
+    paginate(options: PaginateOptions): FindResult<T, TReturn>;
+    UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>>;
+}
+
+interface CountArgs<T extends Entity> {
+    where?: WhereQuery<T>;
+    pool?: Pool;
+}
+
+interface IReadonlyRepository<T extends Entity> {
+    readonly model: ModelMetadata<T>;
+    /**
+     * Gets a single object
+     * @param {object} [args] - Arguments
+     * @param {string[]} [args.select] - Array of model property names to return from the query.
+     * @param {object} [args.where] - Object representing the where query
+     * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
+     * @param {object} [args.pool] - Override the db pool to use for the query
+     */
+    findOne<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | 'id'>>>(args: FindOneArgs<T, K> | WhereQuery<T>): FindOneResult<T, TReturn>;
+    /**
+     * Gets a collection of objects
+     * @param {object} [args] - Arguments
+     * @param {string[]} [args.select] - Array of model property names to return from the query.
+     * @param {object} [args.where] - Object representing the where query
+     * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
+     * @param {string|number} [args.skip] - Number of records to skip
+     * @param {string|number} [args.limit] - Number of results to return
+     * @param {object} [args.pool] - Override the db pool to use for the query
+     */
+    find<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | 'id'>>>(args: FindArgs<T, K> | WhereQuery<T>): FindResult<T, TReturn>;
+    /**
+     * Gets a count of rows matching the where query
+     * @param {object} [args] - Arguments
+     * @param {object} [args.where] - Object representing the where query
+     * @param {object} [args.pool] - Override the db pool to use for the query
+     * @returns {number} Number of records matching the where criteria
+     */
+    count(args?: CountArgs<T> | WhereQuery<T>): CountResult<T>;
+}
+
+type OnConflictTargets<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = K[] | {
+    columns: K[];
+    where: WhereQuery<T>;
+};
+interface OnConflictIgnoreOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> {
+    onConflict: {
+        action: 'ignore';
+        targets: OnConflictTargets<T, K>;
+    };
+}
+interface OnConflictMergeOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> {
+    onConflict: {
+        action: 'merge';
+        targets: OnConflictTargets<T, K>;
+        merge?: K[] | {
+            columns?: K[];
+            where: WhereQuery<T>;
+        };
+    };
+}
+type OnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = OnConflictIgnoreOptions<T, K> | OnConflictMergeOptions<T, K>;
+
+type CreateOnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = OnConflictOptions<T, K> & Partial<DoNotReturnRecords | ReturnSelect$1<T>>;
+type CreateOptionalOnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = Partial<OnConflictOptions<T, K>> & (DoNotReturnRecords | ReturnSelect$1<T>);
+type CreateOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = CreateOnConflictOptions<T, K> | CreateOptionalOnConflictOptions<T, K>;
+
+interface IRepository<T extends Entity> extends IReadonlyRepository<T> {
+    /**
+     * Creates an object using the specified values
+     * @param {object} values - Values to insert as multiple new objects.
+     * @param {object} [options]
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @returns {object}
+     */
+    create(values: CreateUpdateParams<T>, options?: OnConflictOptions<T> | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): Promise<QueryResult<T>>;
+    /**
+     * Creates an object or objects using the specified values
+     * @param {object|object[]} values - Values to insert as multiple new objects.
+     * @param {object} options
+     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @returns {void}
+     */
+    create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options: DoNotReturnRecords & Partial<OnConflictOptions<T>>): Promise<void>;
+    /**
+     * Creates objects using the specified values
+     * @param {object[]} values - Values to insert as multiple new objects.
+     * @param {object} [options]
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    create(values: CreateUpdateParams<T>[], options?: (OnConflictOptions<T> & Partial<ReturnSelect$1<T>>) | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): Promise<QueryResult<T>[]>;
+    /**
+     * Creates an object using the specified values
+     * @param {object|object[]} values - Values to insert as a new object. If an array is specified, multiple rows will be inserted
+     * @param {object} [options]
+     * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @returns {object|object[]|void} Return value from the db
+     */
+    create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options?: CreateOptions<T>): Promise<QueryResult<T>[]> | Promise<QueryResult<T>> | Promise<void>;
+    /**
+     * Updates object(s) matching the where query, with the specified values
+     * @param {object} where - Object representing the where query
+     * @param {object} values - Values to update
+     * @param {object} options
+     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+     * @param {{returnRecords: false}} options
+     * @returns {void}
+     */
+    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options: DoNotReturnRecords): Promise<void>;
+    /**
+     * Updates object(s) matching the where query, with the specified values
+     * @param {object} where - Object representing the where query
+     * @param {object} values - Values to update
+     * @param {object} [options] - Values to update
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: ReturnSelect$1<T>): Promise<QueryResult<T>[]>;
+    /**
+     * Updates object(s) matching the where query, with the specified values
+     * @param {object} where - Object representing the where query
+     * @param {object} values - Values to update
+     * @param {object} [options]
+     * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]|void} Return values from the db or `true` if returnRecords=false
+     */
+    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: CreateUpdateOptions<T>): Promise<QueryResult<T>[]> | Promise<void>;
+    /**
+     * Destroys object(s) matching the where query
+     * @param {object} [where] - Object representing the where query
+     * @returns {void}
+     */
+    destroy(where?: WhereQuery<T>): DestroyResult<T, void>;
+    /**
+     * Destroys object(s) matching the where query
+     * @param {object} where - Object representing the where query
+     * @param {object} options - Determines if inserted records should be returned
+     * @param {boolean} [options.returnRecords] - Determines if inserted records should be returned
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResult<T, QueryResult<T>[]>;
+    /**
+     * Destroys object(s) matching the where query
+     * @param {object} where - Object representing the where query
+     * @param {object} [options]
+     * @param {boolean} [options.returnRecords=false] - Determines if inserted records should be returned
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]|void} `void` or records affected if returnRecords=true
+     */
+    destroy<TOptions extends DeleteOptions<T> = DeleteOptions<T>>(where: WhereQuery<T>, options?: TOptions): TOptions extends DeleteOptions<T> ? Promise<void> : DestroyResult<T, QueryResult<T>[]>;
+}
+
+interface IRepositoryOptions<T extends Entity> {
+    modelMetadata: ModelMetadata<T>;
+    type: EntityStatic<T>;
+    repositoriesByModelNameLowered: Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+    pool: Pool;
+    readonlyPool?: Pool;
+}
+interface Populate {
+    propertyName: string;
+    where?: WhereQuery<Entity>;
+    select?: string[];
+    sort?: SortObject<Entity> | string;
+    skip?: number;
+    limit?: number;
+    pool?: Pool;
+}
+declare class ReadonlyRepository<T extends Entity> implements IReadonlyRepository<T> {
+    private readonly _modelMetadata;
+    protected _type: EntityStatic<T>;
+    protected _pool: Pool;
+    protected _readonlyPool: Pool;
+    protected _repositoriesByModelNameLowered: Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+    protected _floatProperties: string[];
+    protected _intProperties: string[];
+    constructor({ modelMetadata, type, pool, readonlyPool, repositoriesByModelNameLowered }: IRepositoryOptions<T>);
+    get model(): ModelMetadata<T>;
+    /**
+     * Gets a single object
+     * @param {object} [args] - Arguments
+     * @param {string[]} [args.select] - Array of model property names to return from the query.
+     * @param {object} [args.where] - Object representing the where query
+     * @param {string|object} [args.sort] - Property name(s) to sort by
+     */
+    findOne<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | keyof PickFunctions<T> | 'id'>>>(args?: FindOneArgs<T, K> | WhereQuery<T>): FindOneResult<T, TReturn>;
+    /**
+     * Gets a collection of objects
+     * @param {object} [args] - Arguments
+     * @param {string[]} [args.select] - Array of model property names to return from the query.
+     * @param {object} [args.where] - Object representing the where query
+     * @param {string|object} [args.sort] - Property name(s) to sort by
+     * @param {string|number} [args.skip] - Number of records to skip
+     * @param {string|number} [args.limit] - Number of results to return
+     */
+    find<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | keyof PickFunctions<T> | 'id'>>>(args?: FindArgs<T, K> | WhereQuery<T>): FindResult<T, TReturn>;
+    /**
+     * Gets a count of rows matching the where query
+     * @param {object} [args] - Arguments
+     * @param {object} [args.where] - Object representing the where query
+     * @param {object} [args.pool] - Override the db pool to use for the query
+     * @returns {number} Number of records matching the where criteria
+     */
+    count(args?: CountArgs<T> | WhereQuery<T>): CountResult<T>;
+    protected _buildInstance(row: Partial<QueryResult<T>>): QueryResult<T>;
+    protected _buildInstances(rows: Partial<QueryResult<T>>[]): QueryResult<T>[];
+    protected _convertSortsToOrderBy(sorts: SortObject<T> | string): OrderBy<T>[];
+    protected populateFields(entities: QueryResult<T>[], populates: Populate[]): Promise<void>;
+    private populateSingleAssociation;
+    private populateOneManyCollection;
+    private populateManyManyCollection;
+}
+
+declare class Repository<T extends Entity> extends ReadonlyRepository<T> implements IRepository<T> {
+    /**
+     * Creates an object using the specified values
+     * @param {object} values - Values to insert as multiple new objects.
+     * @param {object} [options]
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @returns {object}
+     */
+    create(values: CreateUpdateParams<T>, options?: OnConflictOptions<T> | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): Promise<QueryResult<T>>;
+    /**
+     * Creates an object or objects using the specified values
+     * @param {object|object[]} values - Values to insert as multiple new objects.
+     * @param {object} options
+     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @returns {void}
+     */
+    create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options: DoNotReturnRecords & Partial<OnConflictOptions<T>>): Promise<void>;
+    /**
+     * Creates objects using the specified values
+     * @param {object[]} values - Values to insert as multiple new objects.
+     * @param {object} [options]
+     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    create(values: CreateUpdateParams<T>[], options?: (OnConflictOptions<T> & Partial<ReturnSelect$1<T>>) | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): Promise<QueryResult<T>[]>;
+    /**
+     * Updates object(s) matching the where query, with the specified values
+     * @param {object} where - Object representing the where query
+     * @param {object} values - Values to update
+     * @param {object} options
+     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+     * @returns {void}
+     */
+    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options: DoNotReturnRecords): Promise<void>;
+    /**
+     * Updates object(s) matching the where query, with the specified values
+     * @param {object} where - Object representing the where query
+     * @param {object} values - Values to update
+     * @param {object} [options] - Values to update
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: ReturnSelect$1<T>): Promise<QueryResult<T>[]>;
+    /**
+     * Destroys object(s) matching the where query
+     * @param {object} [where] - Object representing the where query
+     * @returns {void}
+     */
+    destroy(where?: WhereQuery<T>): DestroyResult<T, void>;
+    /**
+     * Destroys object(s) matching the where query
+     * @param {object} where - Object representing the where query
+     * @param {object} options - Determines if inserted records should be returned
+     * @param {boolean} [options.returnRecords] - Determines if inserted records should be returned
+     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+     * @returns {object[]}
+     */
+    destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResult<T, QueryResult<T>[]>;
+}
+
+interface ColumnBaseOptions {
+    /**
+     * Column name in the database
+     */
+    name?: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+}
+
+interface ColumnCollectionOptions extends ColumnBaseOptions {
+    /**
+     * Type of the items in the collection
+     */
+    collection: string | (() => string);
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    through?: string | (() => string);
+}
+
+interface ColumnModelOptions extends ColumnBaseOptions {
+    /**
+     * Type of the entity represented by this column id
+     */
+    model: string | (() => string);
+}
+
+interface ColumnTypeOptions extends ColumnBaseOptions {
+    /**
+     * Type of the column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+}
+
+type ColumnOptions$1 = ColumnCollectionOptions | ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$5 = (object: ClassLike, propertyName: string) => void;
+declare function column(options?: ColumnOptions$1): ReturnFunctionType$5;
+declare function column(dbColumnName: string, options?: ColumnOptions$1): ReturnFunctionType$5;
+
+type ReturnFunctionType$4 = (object: ClassLike, propertyName: string) => void;
+declare function createDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$4;
+declare function createDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$4;
+
+type ColumnOptions = ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$3 = (object: ClassLike, propertyName: string) => void;
+declare function primaryColumn(options?: ColumnOptions): ReturnFunctionType$3;
+declare function primaryColumn(dbColumnName: string, options?: ColumnOptions): ReturnFunctionType$3;
+
+interface TableOptions {
+    /**
+     * Table name in the database
+     */
+    name?: string;
+    /**
+     * Connection name to use for queries
+     */
+    connection?: string;
+    /**
+     * Indicates if create, update, delete statements should be available
+     */
+    readonly?: boolean;
+}
+
+type ReturnFunctionType$2 = (object: any) => void;
+declare function table(options?: TableOptions): ReturnFunctionType$2;
+declare function table(dbName: string, options: TableOptions): ReturnFunctionType$2;
+
+type ReturnFunctionType$1 = (object: ClassLike, propertyName: string) => void;
+declare function updateDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$1;
+declare function updateDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$1;
+
+type ReturnFunctionType = (object: ClassLike, propertyName: string) => void;
+declare function versionColumn(options?: ColumnTypeOptions): ReturnFunctionType;
+declare function versionColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType;
+
+interface IConnection {
+    pool: Pool;
+    readonlyPool?: Pool;
+}
+interface InitializeOptions extends IConnection {
+    models: EntityStatic<Entity>[];
+    connections?: Record<string, IConnection>;
+    expose?: (repository: ReadonlyRepository<Entity> | Repository<Entity>, tableMetadata: ModelMetadata<Entity>) => void;
+}
+/**
+ * Initializes BigAl
+ * @param {object[]} models - Model classes - used to force decorator evaluation for all models
+ * @param {object[]} modelSchemas - Model definitions
+ * @param {object} pool - Postgres Pool
+ * @param {object} [readonlyPool] - Postgres Pool for `find` and `findOne` operations. If not defined, `pool` will be used
+ * @param {object} [connections] - Key: name of the connection; Value: { pool, readonlyPool }
+ * @param {Function} [expose] - Used to expose model classes
+ * @returns {object} Repositories by model name
+ */
+declare function initialize({ models, pool, readonlyPool, connections, expose }: InitializeOptions): Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+
+export { type ClassLike, ColumnBaseMetadata, type ColumnBaseMetadataOptions, ColumnCollectionMetadata, type ColumnCollectionMetadataOptions, type ColumnMetadata, ColumnModelMetadata, type ColumnModelMetadataOptions, type ColumnModifierMetadata, ColumnTypeMetadata, type ColumnTypeMetadataOptions, type CreateUpdateParams, Entity, type EntityFieldValue, type EntityPrimitiveOrId, type EntityStatic, type ExcludeEntityCollections, type ExcludeFunctions, type GetValueType, type IConnection, type IReadonlyRepository, type IRepository, type IRepositoryOptions, type IncludeFunctions, type InitializeOptions, type IsValueOfType, ModelMetadata, type ModelMetadataOptions, type NotEntity, type NotEntityBrand, type OmitEntityCollections, type OmitFunctions, type PickAsType, type PickByValueType, type PickFunctions, type Populated, type QueryResult, type QueryResultOptionalPopulated, type QueryResultPopulated, ReadonlyRepository, Repository, column, createDateColumn, getMetadataStorage, initialize, primaryColumn, table, updateDateColumn, versionColumn };