@tstdl/base 0.92.122 → 0.92.124

package/types/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/types/orm/data-types/bytea.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `bytea` columns.
+ */
+import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
+type Config = {
+    data: Uint8Array;
+    driverData: Uint8Array;
+};
+/**
+ * Custom Drizzle type for PostgreSQL `bytea` columns.
+ * Maps between `Uint8Array` in JavaScript and `bytea` in the database.
+ */
+export declare const bytea: {
+    (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
+    <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;
+};
+export {};

package/types/orm/data-types/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Exports custom Drizzle data types for PostgreSQL.
+ */
+export * from './bytea.js';
+export * from './numeric-date.js';
+export * from './timestamp.js';

package/types/orm/data-types/numeric-date.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `date` columns
+ * using numeric representation (YYYYMMDD).
+ */
+import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
+type Config = {
+    data: number;
+    driverData: string;
+};
+/**
+ * Custom Drizzle type for PostgreSQL `date` columns, storing dates as numeric values (YYYYMMDD).
+ * Converts between JavaScript `number` (YYYYMMDD) and database `date` (ISO string).
+ */
+export declare const numericDate: {
+    (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
+    <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;
+};
+export {};

package/types/orm/data-types/timestamp.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `timestamp with time zone` columns
+ * using numeric representation (Unix timestamp in milliseconds).
+ */
+import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
+type Config = {
+    data: number;
+    driverData: string;
+};
+/**
+ * Custom Drizzle type for PostgreSQL `timestamp with time zone` columns, storing timestamps as numeric values (Unix timestamp in milliseconds).
+ * Converts between JavaScript `number` (milliseconds since epoch) and database `timestamp with time zone` (ISO string).
+ */
+export declare const timestamp: {
+    (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
+    <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;
+};
+export {};

package/types/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/types/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>>;
+}

package/types/orm/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module
+ * Barrel file exporting core ORM functionalities including data types,
+ * base entities, query types, repository types, SQL helpers, and utility types.
+ */
+export * from './data-types/index.js';
+export * from './entity.js';
+export * from './query.js';
+export * from './repository.types.js';
+export * from './sqls.js';
+export * from './types.js';
+export * from './utils.js';

package/types/orm/query.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @module
+ * Defines types for constructing database queries using a MongoDB-like syntax.
+ * Supports logical operators, comparison operators, and specialized queries like text search and geospatial queries.
+ */
+import type { SQLWrapper } from 'drizzle-orm';
+import type { Flatten, Record } from '../../types.js';
+import type { Geometry } from '../../types/geo-json.js';
+import type { UntaggedDeep } from '../../types/tagged.js';
+/** Represents a logical query combining multiple sub-queries (e.g., $and, $or, $nor). */
+export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
+/** Union of keys representing logical query operators ('$and', '$or', '$nor'). */
+export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & LogicalNorQuery);
+/** Array containing all valid logical query operator keys. */
+export declare const allLogicalQueryTypes: LogicalQueryTypes[];
+/** Represents the body of a comparison query, mapping field paths to comparison operators or values. Allows nested structures. */
+export type ComparisonQueryBody<T = any> = {
+    [P in keyof T]?: T[P] extends Record ? ComparisonQueryBody<T[P]> : ComparisonQueryOrValue<T[P]>;
+} & Record<ComparisonQueryOrValue>;
+/** Represents either a full comparison query object or a direct value for equality comparison. */
+export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | ComparisonValue<T>;
+/** Represents a comparison query using various operators like $eq, $ne, $gt, $in, etc. */
+export type ComparisonQuery<T = any> = Partial<ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
+/** Union of keys representing comparison query operators. */
+export type ComparisonQueryTypes = keyof ComparisonQuery;
+/** Array containing all valid comparison query operator keys. */
+export declare const allComparisonQueryTypes: ComparisonQueryTypes[];
+/** Represents specialized query types beyond simple comparisons (e.g., $textSpan). */
+export type SpecialQuery<T = any> = Partial<TextSpanQuery<T>>;
+/** Union of keys representing special query operators. */
+export type SpecialQueryTypes = keyof SpecialQuery;
+/** Array containing all valid special query operator keys. */
+export declare const allSpecialQueryTypes: SpecialQueryTypes[];
+/**
+ * Represents a complete query, which can be either a raw Drizzle SQLWrapper
+ * or a structured query object using logical and comparison operators.
+ * @template T - The type of the entity being queried.
+ */
+export type Query<T = any> = SQLWrapper | QueryObject<UntaggedDeep<T>>;
+/** Represents a structured query object, combining logical, comparison, and special queries. */
+export type QueryObject<T> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
+/** Union of all possible query operator keys (logical, comparison, special). */
+export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
+/** Array containing all valid query operator keys. */
+export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
+/** Logical operators used within certain query types like $text. */
+export type Operator = 'and' | 'or';
+/** Array containing all valid logical operators ('and', 'or'). */
+export declare const allOperators: Operator[];
+/** Represents an AND logical query. All sub-queries must be true. */
+export type LogicalAndQuery<T = any> = {
+    $and: readonly Query<T>[];
+};
+/** Represents an OR logical query. At least one sub-query must be true. */
+export type LogicalOrQuery<T = any> = {
+    $or: readonly Query<T>[];
+};
+/** Represents a NOR logical query. All sub-queries must be false. */
+export type LogicalNorQuery<T = any> = {
+    $nor: readonly Query<T>[];
+};
+/** Represents a value used in comparisons, can be a direct value, a flattened value, or a Drizzle SQLWrapper. */
+export type ComparisonValue<T> = T | Flatten<T> | SQLWrapper;
+/** Represents a comparison value that can also include a RegExp for string comparisons. */
+export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+/** Represents a NOT comparison query. Inverts the result of the nested comparison. */
+export type ComparisonNotQuery<T = any> = {
+    $not: ComparisonQuery<T>;
+};
+/** Represents an equality comparison query ($eq). */
+export type ComparisonEqualsQuery<T = any> = {
+    $eq: ComparisonValueWithRegex<T>;
+};
+/** Represents a non-equality comparison query ($neq). */
+export type ComparisonNotEqualsQuery<T = any> = {
+    $neq: ComparisonValueWithRegex<T>;
+};
+/** Represents an existence check query ($exists). Checks if a field exists (or not). */
+export type ComparisonExistsQuery = {
+    $exists: ComparisonValue<boolean>;
+};
+/** Represents a query targeting elements within an array field ($item). */
+export type ComparisonItemQuery<T = any> = {
+    $item: T extends readonly (infer U)[] ? U extends Record ? Query<U> : ComparisonQuery<U> : never;
+};
+/** Represents an "in list" comparison query ($in). Checks if a field value is within a specified array. */
+export type ComparisonInQuery<T = any> = {
+    $in: readonly ComparisonValueWithRegex<T>[];
+};
+/** Represents a "not in list" comparison query ($nin). Checks if a field value is not within a specified array. */
+export type ComparisonNotInQuery<T = any> = {
+    $nin: readonly ComparisonValueWithRegex<T>[];
+};
+/** Represents an "all elements match" query ($all). Checks if an array field contains all specified values. */
+export type ComparisonAllQuery<T = any> = {
+    $all: readonly ComparisonValueWithRegex<T>[];
+};
+/** Represents a "greater than" comparison query ($gt). */
+export type ComparisonGreaterThanQuery<T = any> = {
+    $gt: ComparisonValue<T>;
+};
+/** Represents a "greater than or equals" comparison query ($gte). */
+export type ComparisonGreaterThanOrEqualsQuery<T = any> = {
+    $gte: ComparisonValue<T>;
+};
+/** Represents a "less than" comparison query ($lt). */
+export type ComparisonLessThanQuery<T = any> = {
+    $lt: ComparisonValue<T>;
+};
+/** Represents a "less than or equals" comparison query ($lte). */
+export type ComparisonLessThanOrEqualsQuery<T = any> = {
+    $lte: ComparisonValue<T>;
+};
+/** Represents a regular expression comparison query ($regex). */
+export type ComparisonRegexQuery = {
+    $regex: string | RegExp | {
+        pattern: string;
+        flags: string;
+    };
+};
+/** Represents a full-text search query ($text). */
+export type ComparisonTextQuery = {
+    $text: string | {
+        text: string;
+        operator?: Operator;
+    };
+};
+/** Defines the possible spatial relationships for geospatial shape queries. */
+export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
+/** Represents a geospatial query based on shape relationships ($geoShape). */
+export type ComparisonGeoShapeQuery = {
+    $geoShape: {
+        geometry: Geometry;
+        relation: GeoShapeRelation;
+    };
+};
+/** Represents a geospatial query based on distance from a point ($geoDistance). */
+export type ComparisonGeoDistanceQuery = {
+    $geoDistance: {
+        longitude: number;
+        latitude: number;
+        /**
+         * Maximum distance in meters
+         */
+        maxDistance?: number;
+        /**
+         * Minimum distance in meters
+         */
+        minDistance?: number;
+    };
+};
+/** Defines the modes for text span queries, affecting how multiple field matches are handled. */
+export type TextSpanQueryMode = 'best' | 'most' | 'cross';
+/** Array containing all valid text span query modes. */
+export declare const allTextSpanQueryModes: TextSpanQueryMode[];
+/** Represents a text span query ($textSpan), searching for text across multiple fields. */
+export type TextSpanQuery<T = any> = {
+    $textSpan: {
+        fields: readonly (Extract<keyof T, string>)[];
+        text: string;
+        mode?: TextSpanQueryMode;
+        operator?: Operator;
+    };
+};

package/types/orm/repository.types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @module
+ * Defines types used by ORM repositories for operations like loading, updating, and creating entities.
+ * Includes types for ordering, loading options, and entity data structures for create/update operations.
+ */
+import type { Paths, Record, TypedOmit } from '../../types.js';
+import type { UntaggedDeep } from '../../types/tagged.js';
+import type { SQL, SQLWrapper } from 'drizzle-orm';
+import type { PartialDeep } from 'type-fest';
+import type { Entity, EntityMetadata, EntityWithoutMetadata } from './entity.js';
+type WithSql<T> = {
+    [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL);
+};
+/**
+ * Specifies the target column (e.g. for ordering, distinct on), which can be a property path within the entity
+ * or a raw Drizzle SQLWrapper for a complex target.
+ * @template T - The entity type.
+ */
+export type TargetColumnPaths<T extends EntityWithoutMetadata> = Paths<UntaggedDeep<T>>;
+/**
+ * Specifies the target column (e.g. for ordering, distinct on), which can be a property path within the entity
+ * or a raw Drizzle SQLWrapper for a complex target.
+ * @template T - The entity type.
+ */
+export type TargetColumn<T extends EntityWithoutMetadata> = TargetColumnPaths<T> | SQLWrapper;
+/** Specifies the direction for ordering results ('asc' or 'desc'). */
+export type OrderDirection = 'asc' | 'desc';
+/**
+ * Defines how results should be ordered. Can be a single target, an array of targets
+ * (optionally with direction), or an object mapping property paths to directions.
+ * @template T - The entity type.
+ */
+export type Order<T extends EntityWithoutMetadata> = TargetColumn<T> | (TargetColumn<T> | [TargetColumn<T>, OrderDirection])[] | Partial<Record<Exclude<TargetColumn<T>, SQLWrapper>, OrderDirection>>;
+/**
+ * Options object containing ordering configuration.
+ * @template T - The entity type.
+ */
+export type OrderOptions<T extends EntityWithoutMetadata> = {
+    order?: Order<T>;
+};
+/**
+ * Options for loading a single entity, including ordering and offset.
+ * @template T - The entity type.
+ */
+export type LoadOptions<T extends EntityWithoutMetadata> = OrderOptions<T> & {
+    offset?: number;
+};
+/**
+ * Options for loading multiple entities, including ordering, offset, and limit.
+ * @template T - The entity type.
+ */
+export type LoadManyOptions<T extends EntityWithoutMetadata> = LoadOptions<T> & {
+    limit?: number;
+    distinct?: boolean | TargetColumn<T>[];
+};
+/**
+ * Options for update operations (currently inherits from LoadOptions, primarily for ordering).
+ * @template T - The entity type.
+ */
+export type UpdateOptions<T extends EntityWithoutMetadata> = LoadOptions<T>;
+/** Type definition for updating entity metadata attributes, allowing partial updates and SQL expressions. */
+export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>>;
+/**
+ * Represents the data structure for creating a new entity.
+ * Excludes 'id' and 'metadata' by default, but allows providing an optional 'id' and partial 'metadata.attributes'.
+ * Allows SQL expressions for values.
+ * @template T - The entity type.
+ */
+export type NewEntity<T extends Entity | EntityWithoutMetadata> = T extends Entity ? WithSql<UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & {
+    id?: string;
+    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
+}>> : WithSql<UntaggedDeep<TypedOmit<T, 'id'> & {
+    id?: string;
+}>>;
+/**
+ * Represents the data structure for updating an existing entity.
+ * Allows partial updates for all properties (using PartialDeep) and specific updates for 'metadata.attributes'.
+ * Allows SQL expressions for values.
+ * @template T - The entity type.
+ */
+export type EntityUpdate<T extends EntityWithoutMetadata> = T extends Entity ? WithSql<PartialDeep<UntaggedDeep<TypedOmit<T, 'metadata'>>>> & {
+    metadata?: EntityMetadataUpdate;
+} : WithSql<PartialDeep<UntaggedDeep<T>>>;
+export {};

package/types/orm/schemas/json.d.ts

@@ -0,0 +1,9 @@
+import { type Decorator } from '../../../reflection/index.js';
+import { ObjectSchema, type ObjectSchemaOptions, type SchemaDecoratorOptions } from '../../../schema/index.js';
+export type JsonSchemaOptions = Pick<ObjectSchemaOptions, 'factory'>;
+export declare class JsonSchema extends ObjectSchema {
+    readonly name = "Json";
+    constructor(options?: JsonSchemaOptions);
+}
+export declare function json(options?: JsonSchemaOptions): JsonSchema;
+export declare function Json(options?: JsonSchemaOptions & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;

package/types/orm/schemas/numeric-date.d.ts

@@ -0,0 +1,8 @@
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SimpleSchemaOptions } from '../../../schema/index.js';
+export type NumericDateSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
+export declare class NumericDateSchema extends NumberSchema {
+    readonly name = "NumericDate";
+    constructor(options?: NumericDateSchemaOptions);
+}
+export declare function numericDate(options?: NumericDateSchemaOptions): NumericDateSchema;
+export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/orm/schemas/timestamp.d.ts

@@ -0,0 +1,10 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../../schema/index.js';
+export type TimestampSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
+export declare class TimestampSchema extends NumberSchema {
+    readonly name = "Timestamp";
+    constructor(options?: TimestampSchemaOptions);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<number>;
+}
+export declare function timestamp(options?: TimestampSchemaOptions): TimestampSchema;
+export declare function Timestamp(options?: TimestampSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/orm/schemas/uuid.d.ts

@@ -0,0 +1,11 @@
+import { StringSchema, type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../../../schema/index.js';
+export type UuidSchemaOptions = {
+    defaultRandom?: boolean;
+};
+export declare class UuidSchema extends StringSchema {
+    readonly name = "uuid";
+    readonly defaultRandom: boolean;
+    constructor(options?: UuidSchemaOptions);
+}
+export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
+export declare function Uuid(options?: UuidSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;