@tstdl/base 0.92.124 → 0.92.126

package/migration/mongo/module.d.ts

@@ -0,0 +1,12 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
+import type { MigrationState } from '../../migration/migration-state.js';
+export type MongoMigrationStateRepositoryModuleConfig = {
+    defaultMigrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState> | undefined;
+};
+export declare const mongoMigrationStateRepositoryModuleConfig: MongoMigrationStateRepositoryModuleConfig;
+/**
+ * configure mongo migration state repository module
+ * @param migrationStateRepositoryConfig repository configuration for states
+ * @param register whether to register for {@link MigrationStateRepository}
+ */
+export declare function configureMongoMigrationStateRepository(migrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState>, register?: boolean): void;

package/module/module-base.d.ts

@@ -0,0 +1,18 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import { CancellationToken } from '../cancellation/index.js';
+import type { StringMap } from '../types.js';
+import type { Module, ModuleMetric } from './module.js';
+import { ModuleState } from './module.js';
+export declare abstract class ModuleBase implements Module {
+    private runPromise;
+    private _state;
+    protected readonly cancellationToken: CancellationToken;
+    readonly name: string;
+    abstract readonly metrics: StringMap<ModuleMetric>;
+    get state(): ModuleState;
+    private get stateString();
+    constructor(name: string);
+    run(): Promise<void>;
+    stop(): Promise<void>;
+    protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;
+}

package/module/module-metric-reporter.d.ts

@@ -0,0 +1,29 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import type { MetricAggregation, MetricAggregationOptions } from '../utils/moving-metric.js';
+import { MovingMetric } from '../utils/moving-metric.js';
+import type { ModuleMetric } from './module.js';
+export type MetricReport<Aggregation extends MetricAggregation> = {
+    displayName: string;
+    aggregation: Aggregation;
+    aggregationOptions?: MetricAggregationOptions<Aggregation>;
+};
+export type MetricReportRegistration = {
+    metric: ModuleMetric;
+    moving: MovingMetric;
+    reports: MetricReport<MetricAggregation>[];
+};
+export declare class ModuleMetricReporter {
+    private readonly metricGroups;
+    private readonly sampleInterval;
+    private readonly sampleCount;
+    private readonly reportEveryNthSample;
+    private longestGroupName;
+    private longestDisplayName;
+    constructor(sampleInterval: number, sampleCount: number, reportEveryNthSample: number);
+    register(groupName: string, ...metrics: {
+        metric: ModuleMetric;
+        reports: MetricReport<MetricAggregation>[];
+    }[]): void;
+    run(cancellationSignal: CancellationSignal): Promise<void>;
+    private updateNameLengths;
+}

package/module/module.d.ts

@@ -0,0 +1,23 @@
+import type { StringMap } from '../types.js';
+export declare enum ModuleMetricType {
+    Counter = 0,
+    Gauge = 1
+}
+export type ModuleMetric = {
+    type: ModuleMetricType;
+    labels?: string[];
+    getValue(): number;
+};
+export declare enum ModuleState {
+    Running = 0,
+    Stopping = 1,
+    Stopped = 2,
+    Erroneous = 3
+}
+export interface Module {
+    readonly name: string;
+    readonly state: ModuleState;
+    readonly metrics: StringMap<ModuleMetric>;
+    run(): Promise<void>;
+    stop(): Promise<void>;
+}

package/module/modules/function.module.d.ts

@@ -0,0 +1,10 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
+import { ModuleBase } from '../module-base.js';
+import type { Module } from '../module.js';
+export type FunctionModuleFunction = (cancellationToken: CancellationSignal) => void | Promise<void>;
+export declare class FunctionModule extends ModuleBase implements Module {
+    private readonly fn;
+    readonly metrics: {};
+    constructor(fn: FunctionModuleFunction, name?: string);
+    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
+}

package/module/modules/web-server.module.d.ts

@@ -0,0 +1,27 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { ModuleBase } from '../module-base.js';
+import type { Module } from '../module.js';
+import { ModuleMetricType } from '../module.js';
+export type WebServerModuleConfiguration = {
+    port: number;
+};
+export declare const webServerModuleConfiguration: WebServerModuleConfiguration;
+export declare class WebServerModule extends ModuleBase implements Module, Resolvable<WebServerModuleConfiguration> {
+    private readonly config;
+    private readonly httpServer;
+    private readonly apiGateway;
+    private readonly apiControllers;
+    private initialized;
+    readonly metrics: {
+        connectedSockets: {
+            type: ModuleMetricType;
+            getValue: () => number;
+        };
+    };
+    readonly [resolveArgumentType]: WebServerModuleConfiguration;
+    constructor();
+    initialize(): void;
+    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
+}
+export declare function configureWebServerModule(config?: Partial<WebServerModuleConfiguration>): void;

package/module/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from '../logger/index.js';
+import type { Module } from './module.js';
+export declare function runModules(modules: Module[], logger?: Logger): Promise<void>;
+export declare function stopModules(modules: Module[], logger?: Logger): Promise<void>;

package/object-storage/object-storage.d.ts

@@ -0,0 +1,75 @@
+import { resolveArgumentType, type Resolvable } from '../injector/interfaces.js';
+import type { ObjectMetadata, ObjectStorageObject } from './object.js';
+export type UploadObjectOptions = {
+    contentLength?: number;
+    metadata?: ObjectMetadata;
+};
+export type ObjectStorageArgument = string;
+export declare abstract class ObjectStorage implements Resolvable<ObjectStorageArgument> {
+    /** Object storage module */
+    readonly module: string;
+    readonly [resolveArgumentType]: ObjectStorageArgument;
+    constructor(module: string);
+    /**
+     * Checks if an object exists
+     * @param key object key
+     */
+    abstract exists(key: string): Promise<boolean>;
+    /**
+     * Uploads an object
+     * @param key object key
+     * @param content content of object
+     */
+    abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    /**
+     * Get an url which can be used to upload the object without further authorization
+     * @param key object key
+     * @param expirationTimestamp timestamp when the url expires and can no longer be used
+     */
+    abstract getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    /**
+     * Get all objects
+     */
+    abstract getObjects(): Promise<ObjectStorageObject[]>;
+    /**
+     * Get all objects
+     */
+    abstract getObjectsCursor(): AsyncIterable<ObjectStorageObject>;
+    /**
+     * Get object
+     * @param key object key
+     */
+    abstract getObject(key: string): Promise<ObjectStorageObject>;
+    /**
+     * Get object resource uri
+     * @param key object key
+     */
+    abstract getResourceUri(key: string): Promise<string>;
+    /**
+     * Get object content
+     * @param key object key
+     */
+    abstract getContent(key: string): Promise<Uint8Array>;
+    /**
+     * Get stream of object content
+     * @param key object key
+     */
+    abstract getContentStream(key: string): ReadableStream<Uint8Array>;
+    /**
+     * Get an url which can be used to download the object without further authorization
+     * @param key object key
+     * @param expirationTimestamp timestamp when the url expires and can no longer be used
+     * @param responseHeaders headers used for download response
+     */
+    abstract getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
+    /**
+     * Deletes an object
+     * @param key object key
+     */
+    abstract deleteObject(key: string): Promise<void>;
+    /**
+     * Deletes objects
+     * @param keys object key
+     */
+    abstract deleteObjects(keys: string[]): Promise<void>;
+}

package/object-storage/object.d.ts

@@ -0,0 +1,12 @@
+import type { Record } from '../types.js';
+export type ObjectMetadata = Record<string>;
+export declare abstract class ObjectStorageObject {
+    readonly module: string;
+    readonly key: string;
+    constructor(module: string, key: string);
+    abstract getResourceUri(): Promise<string>;
+    abstract getContentLength(): Promise<number>;
+    abstract getMetadata(): Promise<ObjectMetadata>;
+    abstract getContent(): Promise<Uint8Array>;
+    abstract getContentStream(): ReadableStream<Uint8Array>;
+}

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -0,0 +1,41 @@
+import { ObjectStorageProvider } from '../../object-storage/index.js';
+import { S3ObjectStorage } from './s3.object-storage.js';
+export declare class S3ObjectStorageProviderConfig {
+    /**
+     * S3 endpoint
+     */
+    endpoint: string;
+    /**
+     * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
+     *
+     * mutually exclusive with bucketPerModule
+     */
+    bucket?: string;
+    /**
+     * Use an own bucket for every module
+     *
+     * mutually exclusive with bucket
+     */
+    bucketPerModule?: boolean;
+    /**
+     * S3 access key
+     */
+    accessKey: string;
+    /**
+     * S3 secret key
+     */
+    secretKey: string;
+}
+export declare const bucketPerModule: unique symbol;
+export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
+    private readonly client;
+    private readonly bucket;
+    constructor(config: S3ObjectStorageProviderConfig);
+    get(module: string): S3ObjectStorage;
+}
+/**
+ * Configure s3 object storage provider
+ * @param config s3 config
+ * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
+ */
+export declare function configureS3ObjectStorage(config: S3ObjectStorageProviderConfig, register?: boolean): void;

package/object-storage/s3/s3.object-storage.d.ts

@@ -0,0 +1,28 @@
+import type { BucketItemStat, Client } from 'minio';
+import { ObjectStorage, type UploadObjectOptions } from '../../object-storage/index.js';
+import { S3Object } from './s3.object.js';
+export declare class S3ObjectStorage extends ObjectStorage {
+    private readonly client;
+    private readonly bucket;
+    private readonly prefix;
+    constructor(client: Client, bucket: string, module: string, keyPrefix: string);
+    ensureBucketExists(region?: string, options?: {
+        objectLocking?: boolean;
+    }): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    statObject(key: string): Promise<BucketItemStat>;
+    uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    getContent(key: string): Promise<Uint8Array>;
+    getContentStream(key: string): ReadableStream<Uint8Array>;
+    getObjects(): Promise<S3Object[]>;
+    getObjectsCursor(): AsyncIterable<S3Object>;
+    getObject(key: string): Promise<S3Object>;
+    getResourceUri(key: string): Promise<string>;
+    getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
+    getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    deleteObject(key: string): Promise<void>;
+    deleteObjects(keys: string[]): Promise<void>;
+    private getResourceUriSync;
+    private getBucketKey;
+    private getKey;
+}

package/object-storage/s3/s3.object.d.ts

@@ -0,0 +1,16 @@
+import type { ObjectMetadata } from '../../object-storage/object.js';
+import { ObjectStorageObject } from '../../object-storage/object.js';
+import type { S3ObjectStorage } from './s3.object-storage.js';
+export declare class S3Object extends ObjectStorageObject {
+    private readonly storage;
+    private readonly resourceUri;
+    private contentLength;
+    private statPromise;
+    constructor(module: string, key: string, resourceUri: string, contentLength: number | undefined, storage: S3ObjectStorage);
+    getResourceUri(): Promise<string>;
+    getContentLength(): Promise<number>;
+    getMetadata(): Promise<ObjectMetadata>;
+    getContent(): Promise<Uint8Array>;
+    getContentStream(): ReadableStream<Uint8Array>;
+    private stat;
+}

package/openid-connect/cached-oidc-configuration.service.d.ts

@@ -0,0 +1,9 @@
+import { HttpClient } from '../http/client/http-client.js';
+import type { OidcConfiguration } from './oidc-configuration.service.js';
+import { OidcConfigurationService } from './oidc-configuration.service.js';
+export declare class CachedOidcConfigurationService extends OidcConfigurationService {
+    private readonly cacheDuration;
+    private readonly cache;
+    constructor(httpClient: HttpClient, cacheDuration?: number);
+    getConfiguration(endpoint: string): Promise<OidcConfiguration>;
+}

package/openid-connect/mongo-oidc-state.repository.d.ts

@@ -0,0 +1,21 @@
+import type { CollectionArgument, MongoRepositoryConfig } from '../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../database/mongo/index.js';
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import { Logger } from '../logger/index.js';
+import type { TypedOmit } from '../types.js';
+import type { OidcState } from './oidc-state.model.js';
+import { OidcStateRepository } from './oidc-state.repository.js';
+export type MongoOidcState = TypedOmit<OidcState, 'expiration'> & {
+    expiration: Date;
+};
+export declare class MongoOidcStateRepository extends MongoEntityRepository<OidcState, MongoOidcState> implements OidcStateRepository, Resolvable<CollectionArgument<MongoOidcState>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoOidcState>;
+    constructor(collection: Collection<MongoOidcState>, logger: Logger);
+}
+/**
+ * configure mongo oidc state repository module
+ * @param mongoOidcStateRepositoryConfig repository configuration for states
+ * @param register whether to register for {@link OidcStateRepository}
+ */
+export declare function configureMongoOidcStateRepository(mongoOidcStateRepositoryConfig: MongoRepositoryConfig<OidcState, MongoOidcState>, register?: boolean): void;

package/openid-connect/oidc-configuration.service.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from '../http/client/index.js';
+export type OidcConfiguration = {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    revocationEndpoint?: string;
+    userInfoEndpoint?: string;
+    endSessionEndpoint?: string;
+};
+export declare class OidcConfigurationService {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    getConfiguration(endpoint: string): Promise<OidcConfiguration>;
+}

package/openid-connect/oidc-state.model.d.ts

@@ -0,0 +1,11 @@
+import type { Entity, NewEntity } from '../database/index.js';
+export type OidcState<Data = any> = Entity & {
+    value: string;
+    codeVerifier: string;
+    endpoint: string;
+    clientId: string;
+    clientSecret: string;
+    expiration: number;
+    data: Data;
+};
+export type NewOidcState<Data = any> = NewEntity<OidcState<Data>>;

package/openid-connect/oidc-state.repository.d.ts

@@ -0,0 +1,4 @@
+import { EntityRepository } from '../database/index.js';
+import type { OidcState } from './oidc-state.model.js';
+export declare abstract class OidcStateRepository extends EntityRepository<OidcState> {
+}

package/openid-connect/oidc.service.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '../http/client/index.js';
+import type { Record } from '../types.js';
+import { OidcConfigurationService } from './oidc-configuration.service.js';
+import type { OidcState } from './oidc-state.model.js';
+import { OidcStateRepository } from './oidc-state.repository.js';
+import type { OidcGetTokenParameters, OidcInitParameters, OidcInitResult, OidcRefreshTokenParameters, OidcToken } from './oidc.service-model.js';
+export declare class OidcService<Data = any> {
+    private readonly oidcConfigurationService;
+    private readonly maybeOidcStateRepository;
+    private readonly httpClient;
+    private get oidcStateRepository();
+    constructor(oidcConfigurationService: OidcConfigurationService, oidcStateRepository: OidcStateRepository | undefined, httpClient: HttpClient);
+    initAuthorization({ endpoint, clientId, clientSecret, scope, expiration, data }: OidcInitParameters<Data>): Promise<OidcInitResult>;
+    getState(state: string): Promise<OidcState<Data>>;
+    deleteState(state: string): Promise<void>;
+    validateState(state: string): Promise<OidcState<Data>>;
+    getToken(parameters: OidcGetTokenParameters, additionalData?: Record<string, string>): Promise<OidcToken>;
+    refreshToken({ endpoint, clientId, clientSecret, refreshToken }: OidcRefreshTokenParameters): Promise<OidcToken>;
+    getUserInfo(endpoint: string, token: OidcToken): Promise<unknown>;
+}

package/orm/decorators.d.ts

@@ -0,0 +1,212 @@
+/**
+ * @module
+ * Defines decorators for ORM entities and columns, used to configure database schema mapping.
+ */
+import type { SQL } from 'drizzle-orm';
+import type { LiteralUnion } from 'type-fest';
+import type { AbstractConstructor, TypedOmit } from '../types.js';
+import type { Entity, EntityType, EntityWithoutMetadata } from './entity.js';
+import type { Query } from './query.js';
+import type { PgTableFromType } from './server/types.js';
+type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
+type NamingStrategy = 'abbreviated-table';
+type Columns<T> = [Extract<keyof T, string>, ...Extract<keyof T, string>[]];
+/**
+ * Builder function type for creating SQL check constraints.
+ * @param table - The Drizzle table object.
+ * @returns The SQL check constraint expression.
+ */
+export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<EntityType<T>>) => SQL;
+/**
+ * Builder function type for creating partial index WHERE clauses.
+ * @param table - The Drizzle table object.
+ * @returns The query object representing the WHERE clause.
+ */
+export type WhereBuilder<T extends Entity | EntityWithoutMetadata = any> = (table: PgTableFromType<EntityType<T>>) => Query<T>;
+/**
+ * Reflection data stored for ORM table decorators.
+ */
+export type OrmTableReflectionData = {
+    name?: string;
+    schema?: string;
+    compundPrimaryKeyName?: string;
+    compundPrimaryKeyNaming?: NamingStrategy;
+    unique?: UniqueReflectionData[];
+    index?: IndexReflectionData[];
+    checks?: CheckReflectionData[];
+};
+/**
+ * Reflection data stored for ORM column decorators.
+ */
+export type OrmColumnReflectionData = {
+    name?: string;
+    primaryKey?: boolean;
+    unique?: TypedOmit<UniqueReflectionData, 'columns'>;
+    index?: IndexReflectionData;
+    uuid?: {
+        defaultRandom?: boolean;
+    };
+    embedded?: {
+        type: AbstractConstructor;
+        prefix?: string | null;
+    };
+    references?: () => EntityType;
+    encrypted?: boolean;
+};
+/**
+ * Reflection data for unique constraints.
+ */
+export type UniqueReflectionData = {
+    name?: string;
+    columns?: string[];
+    options?: {
+        nulls?: 'distinct' | 'not distinct';
+        naming?: NamingStrategy;
+    };
+};
+/**
+ * Reflection data for index definitions.
+ * @template T - The entity type.
+ */
+export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any> = {
+    name?: string;
+    columns?: (string | [string, 'asc' | 'desc'])[];
+    order?: 'asc' | 'desc';
+    options?: {
+        using?: IndexMethod;
+        unique?: boolean;
+        where?: WhereBuilder<T>;
+        nulls?: 'first' | 'last';
+        naming?: NamingStrategy;
+    };
+};
+type CheckReflectionData = {
+    name: string;
+    builder: CheckBuilder;
+    options?: {
+        naming?: NamingStrategy;
+    };
+};
+/**
+ * Factory function to create a class decorator for ORM table configuration.
+ * Merges provided data with existing ORM reflection data on the class metadata.
+ * @param data - The ORM table reflection data to add.
+ * @returns A class decorator.
+ */
+export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
+/**
+ * Factory function to create a property decorator for ORM column configuration.
+ * Merges provided data with existing ORM reflection data on the property metadata.
+ * @param data - The ORM column reflection data to add.
+ * @returns A property decorator.
+ */
+export declare function createColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator;
+/**
+ * Factory function to create a decorator applicable to both classes and properties for ORM configuration.
+ * Merges provided data with existing ORM reflection data on the target's metadata.
+ * @param data - The ORM reflection data to add.
+ * @returns A class or property decorator.
+ */
+export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
+/**
+ * Decorator to specify ORM column options.
+ * @param options - Column configuration options.
+ * @returns A property decorator.
+ */
+export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
+/**
+ * Decorator to mark a property as the primary key column.
+ * @returns A property decorator.
+ */
+export declare function PrimaryKey(): PropertyDecorator;
+/**
+ * Decorator to define a foreign key relationship.
+ * @param type - A function returning the referenced entity type.
+ * @returns A property decorator.
+ */
+export declare function References(type: () => EntityType): PropertyDecorator;
+/**
+ * Decorator to define a table check constraint.
+ * @template T - The entity type.
+ * @param name - The name of the check constraint.
+ * @param builder - A function to build the SQL check expression.
+ * @returns A class decorator.
+ */
+export declare function Check<T extends Entity>(name: string, builder: CheckBuilder<T>): ClassDecorator;
+/**
+ * Decorator to mark a column for encryption.
+ * The underlying database type will typically be `bytea`.
+ * @returns A property decorator.
+ */
+export declare function Encrypted(): PropertyDecorator;
+/**
+ * Decorator to embed another class's properties into the current entity's table.
+ * @param type - The constructor of the class to embed.
+ * @param options - Embedding options, like prefixing column names.
+ * @returns A property decorator.
+ */
+export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
+type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
+/**
+ * Decorator to specify the database table name and optionally the schema.
+ * @param name - The table name.
+ * @param options - Additional table options (currently only schema).
+ * @returns A class decorator.
+ */
+export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
+/**
+ * Decorator to specify database table options like name and schema.
+ * @param options - Table options including name and schema.
+ * @returns A class decorator.
+ */
+export declare function Table(options?: TableOptions): ClassDecorator;
+/**
+ * Decorator to define a unique constraint on a single column.
+ * @param name - Optional name for the unique constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A property decorator.
+ */
+export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
+/**
+ * Decorator to define a composite unique constraint on multiple columns.
+ * @template T - The entity type.
+ * @param name - The name of the unique constraint.
+ * @param columns - An array of property names included in the constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A class decorator.
+ */
+export declare function Unique<T>(name: string | undefined, columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+/**
+ * Decorator to define a composite unique constraint on multiple columns.
+ * @template T - The entity type.
+ * @param columns - An array of property names included in the constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A class decorator.
+ */
+export declare function Unique<T>(columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+/**
+ * Decorator to define an index on a single column.
+ * @template T - The entity type.
+ * @param name - Optional name for the index.
+ * @param options - Additional index options (e.g., method, uniqueness, conditions).
+ * @returns A property decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name?: string, options?: IndexReflectionData<T>['options']): PropertyDecorator;
+/**
+ * Decorator to define a composite index on multiple columns.
+ * @template T - The entity type.
+ * @param name - The name of the index.
+ * @param columns - An array of property names (or tuples with direction) included in the index.
+ * @param options - Additional index options.
+ * @returns A class decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name: string, columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+/**
+ * Decorator to define a composite index on multiple columns.
+ * @template T - The entity type.
+ * @param columns - An array of property names (or tuples with direction) included in the index.
+ * @param options - Additional index options.
+ * @returns A class decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+export {};

package/orm/entity.d.ts

@@ -0,0 +1,41 @@
+import type { Type } from '../types.js';
+import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
+/**
+ * Represents the type (constructor) of an entity, potentially holding an entity name.
+ * @template T - The entity class type.
+ */
+export interface EntityType<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> extends Type<T> {
+    readonly entityName?: string;
+}
+/**
+ * Base class for extensible metadata attributes associated with an entity.
+ * Allows storing arbitrary key-value pairs.
+ */
+export declare abstract class EntityMetadataAttributes {
+    [key: string]: unknown;
+}
+/**
+ * Base class defining common metadata fields for entities, such as revision tracking and timestamps.
+ */
+export declare abstract class EntityMetadata {
+    revision: number;
+    revisionTimestamp: Timestamp;
+    createTimestamp: Timestamp;
+    deleteTimestamp: Timestamp | null;
+    attributes: HasDefault<Json<EntityMetadataAttributes>>;
+}
+/**
+ * Abstract base class for entities that include standard metadata.
+ * Provides a default `id` (UUID primary key) and an `metadata` field.
+ */
+export declare abstract class Entity {
+    id: IsPrimaryKey<HasDefault<Uuid>>;
+    metadata: Embedded<EntityMetadata>;
+}
+/**
+ * Abstract base class for entities that do *not* include the standard metadata fields.
+ * Provides only a default `id` (UUID primary key). Useful for simpler tables or join tables.
+ */
+export declare abstract class EntityWithoutMetadata {
+    id: IsPrimaryKey<HasDefault<Uuid>>;
+}