@venizia/ignis 0.0.7-2 → 0.0.7-21

package/dist/base/repositories/common/types.d.ts

@@ -4,199 +4,44 @@ import { z } from '@hono/zod-openapi';
 import { TLogLevel, TNullable } from '@venizia/ignis-helpers';
 import { Column, SQL, createTableRelationsHelpers } from 'drizzle-orm';
 import { RelationTypes } from './constants';
-/**
- * Zod schema for pagination skip parameter.
- * Specifies how many items to skip from the beginning of the result set.
- *
- * @example
- * ```typescript
- * // Skip first 10 items
- * const filter = { skip: 10, limit: 5 };
- * ```
- */
-export declare const SkipSchema: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-/** Type for pagination skip parameter. Inferred from {@link SkipSchema}. */
+/** Zod schema for pagination skip parameter. */
+export declare const SkipSchema: z.ZodOptional<z.ZodNumber>;
 export type TSkip = z.infer<typeof SkipSchema>;
-/**
- * Zod schema for pagination offset parameter.
- * Alternative to skip - specifies the starting position in the result set.
- *
- * @example
- * ```typescript
- * // Start from the 20th item
- * const filter = { offset: 20, limit: 10 };
- * ```
- */
-export declare const OffsetSchema: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-/** Type for pagination offset parameter. Inferred from {@link OffsetSchema}. */
+/** Zod schema for pagination offset parameter. */
+export declare const OffsetSchema: z.ZodOptional<z.ZodNumber>;
 export type TOffset = z.infer<typeof OffsetSchema>;
-/**
- * Zod schema for pagination limit parameter.
- * Specifies the maximum number of items to return in a query.
- * Defaults to {@link DEFAULT_LIMIT} (10).
- *
- * @example
- * ```typescript
- * // Return at most 25 items
- * const filter = { limit: 25 };
- * ```
- */
+/** Zod schema for pagination limit parameter. Defaults to DEFAULT_LIMIT (10). */
 export declare const LimitSchema: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-/** Type for pagination limit parameter. Inferred from {@link LimitSchema}. */
 export type TLimit = z.infer<typeof LimitSchema>;
-/**
- * Zod schema for query ordering/sorting.
- * Supports sorting by regular columns and JSON/JSONB paths.
- *
- * @example
- * ```typescript
- * // Sort by single column
- * const filter = { order: ['createdAt DESC'] };
- *
- * // Sort by multiple columns
- * const filter = { order: ['priority DESC', 'createdAt ASC'] };
- *
- * // Sort by JSON path
- * const filter = { order: ['metadata.score DESC'] };
- * ```
- */
+/** Zod schema for query ordering. Supports regular columns and JSON/JSONB paths. */
 export declare const OrderBySchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
-/** Type for ordering/sorting parameter. Inferred from {@link OrderBySchema}. */
 export type TOrderBy = z.infer<typeof OrderBySchema>;
-/**
- * Zod schema for query where conditions.
- * Supports both object format and JSON string format (for URL query params).
- *
- * Features:
- * - Field equality: `{ name: 'John' }`
- * - Comparison operators: `{ age: { gte: 18 } }`
- * - Logical AND: `{ and: [{ status: 'active' }, { role: 'admin' }] }`
- * - Logical OR: `{ or: [{ status: 'active' }, { isPublished: true }] }`
- * - JSON path queries: `{ 'metadata.score': { gt: 50 } }`
- *
- * @example
- * ```typescript
- * // Simple equality
- * const where = { status: 'active' };
- *
- * // With operators
- * const where = { age: { gte: 18, lt: 65 } };
- *
- * // Logical operations
- * const where = { or: [{ role: 'admin' }, { role: 'moderator' }] };
- * ```
- */
+/** Zod schema for query where conditions. Supports object format and JSON string format. */
 export declare const WhereSchema: z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>;
-/**
- * Type for where clause conditions.
- * Supports field-level conditions and logical AND/OR grouping.
- *
- * @template T - The entity type for type-safe field names
- *
- * @example
- * ```typescript
- * // Type-safe where with entity
- * const where: TWhere<User> = {
- *   email: 'john@example.com',
- *   and: [{ isActive: true }, { role: 'admin' }]
- * };
- * ```
- */
+/** Where clause conditions with field-level conditions and logical AND/OR grouping. */
 export type TWhere<T = any> = {
     [key in keyof T]?: any;
 } & {
     and?: TWhere<T>[];
     or?: TWhere<T>[];
 };
-/**
- * Zod schema for field/column selection.
- * Supports two formats:
- * - Array format: `['id', 'name', 'email']` - include only these fields
- * - Object format: `{ id: true, name: true, password: false }` - include/exclude fields
- *
- * @example
- * ```typescript
- * // Array format - include only specified fields
- * const filter = { fields: ['id', 'name', 'email'] };
- *
- * // Object format - include specific, exclude others
- * const filter = { fields: { id: true, name: true, password: false } };
- * ```
- */
+/** Zod schema for field/column selection. Supports array format or object format. */
 export declare const FieldsSchema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
-/**
- * Type for field selection.
- * Can be an object mapping field names to booleans, or an array of field names.
- *
- * @template T - The entity type for type-safe field names
- */
+/** Field selection -- object mapping field names to booleans, or array of field names. */
 export type TFields<T = any> = Partial<{
     [K in keyof T]: boolean;
 }> | Array<keyof T>;
-/**
- * Zod schema for including related entities in queries.
- * Allows eager loading of related data with optional nested filtering.
- *
- * @example
- * ```typescript
- * // Simple inclusion
- * const filter = { include: [{ relation: 'posts' }] };
- *
- * // With nested scope/filter
- * const filter = {
- *   include: [{
- *     relation: 'posts',
- *     scope: { where: { isPublished: true }, limit: 5 }
- *   }]
- * };
- * ```
- */
+/** Zod schema for including related entities in queries with optional nested filtering. */
 export declare const InclusionSchema: any;
-/**
- * Type for a single relation inclusion configuration.
- *
- * @property relation - The name of the relation to include
- * @property scope - Optional filter to apply to the related entities
- * @property shouldSkipDefaultFilter - If true, skip the default filter for this relation
- */
+/** Single relation inclusion configuration. */
 export type TInclusion = {
     relation: string;
     scope?: TFilter;
     shouldSkipDefaultFilter?: boolean;
 };
-/**
- * Comprehensive Zod schema for repository query filtering.
- * Combines where conditions, field selection, relation inclusion, pagination, and sorting.
- * Supports both object format and JSON string format (for URL query params).
- *
- * @example
- * ```typescript
- * // Complete filter example
- * const filter = {
- *   where: { status: 'active', role: { in: ['admin', 'moderator'] } },
- *   fields: ['id', 'name', 'email'],
- *   include: [{ relation: 'posts', scope: { limit: 5 } }],
- *   order: ['createdAt DESC'],
- *   limit: 20,
- *   skip: 0
- * };
- * ```
- */
+/** Comprehensive Zod schema for repository query filtering. Supports object and JSON string formats. */
 export declare const FilterSchema: any;
-/**
- * Type for comprehensive filter configuration.
- * Used across all repository query methods.
- *
- * @template T - The entity type for type-safe where conditions
- *
- * @property where - Query conditions for filtering results
- * @property fields - Field selection (include/exclude columns)
- * @property include - Related entities to eager load
- * @property order - Sorting order for results
- * @property limit - Maximum number of results to return
- * @property offset - Number of results to skip (alternative to skip)
- * @property skip - Number of results to skip
- */
+/** Comprehensive filter configuration used across all repository query methods. */
 export type TFilter<T = any> = {
     where?: TWhere<T>;
     fields?: TFields;
@@ -206,85 +51,22 @@ export type TFilter<T = any> = {
     offset?: number;
     skip?: number;
 };
-/**
- * Update data supporting both regular fields and JSON path updates.
- * Allows nested JSON/JSONB field updates using dot notation.
- *
- * @template T - The base entity type
- *
- * @example
- * ```typescript
- * // Regular update
- * const data: TUpdateData<User> = { name: 'John' };
- *
- * // JSON path update (nested field)
- * const data: TUpdateData<User> = { 'metadata.theme': 'dark' };
- *
- * // Nested path with array index
- * const data: TUpdateData<User> = { 'settings.items[0].enabled': true };
- *
- * // Mixed regular and JSON path updates
- * const data: TUpdateData<User> = {
- *   name: 'John',
- *   'metadata.theme': 'dark',
- *   'metadata.settings.notifications': true
- * };
- * ```
- */
+/** Update data supporting both regular fields and JSON path updates via dot notation. */
 export type TUpdateData<T = any> = Partial<T> & {
     [jsonPath: string]: any;
 };
-/**
- * Zod schema for count operation results.
- * Returns the total number of matching records.
- */
+/** Zod schema for count operation results. */
 export declare const CountSchema: z.ZodObject<{
     count: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-/** Type for count operation results. Inferred from {@link CountSchema}. */
 export type TCount = z.infer<typeof CountSchema>;
-/**
- * Data range information for paginated queries.
- * Follows HTTP Content-Range header standard format.
- *
- * @property start - The starting index (0-based, inclusive)
- * @property end - The ending index (0-based, inclusive)
- * @property total - The total number of records matching the query
- * @property contentRange - Formatted Content-Range header string
- *
- * @example
- * ```typescript
- * // Query with limit: 10, skip: 20, total records: 100
- * const range: TDataRange = {
- *   start: 20,
- *   end: 29,
- *   total: 100,
- *   contentRange: 'items 20-29/100'
- * };
- *
- * // Use in HTTP response header
- * res.setHeader('Content-Range', range.contentRange);
- * ```
- */
+/** Data range information for paginated queries. Follows HTTP Content-Range standard. */
 export type TDataRange = {
-    /** Starting index (0-based, inclusive) */
     start: number;
-    /** Ending index (0-based, inclusive) */
     end: number;
-    /** Total number of records matching the query */
     total: number;
 };
-/**
- * Options for Drizzle ORM query building.
- * Internal type used by the FilterBuilder to construct Drizzle queries.
- *
- * @property limit - Maximum records to return
- * @property offset - Records to skip
- * @property orderBy - SQL order expressions
- * @property where - SQL where condition
- * @property with - Relation inclusion configuration
- * @property columns - Column selection configuration
- */
+/** Options for Drizzle ORM query building, used internally by FilterBuilder. */
 export type TDrizzleQueryOptions = Partial<{
     limit: number;
     offset: number;
@@ -293,25 +75,7 @@ export type TDrizzleQueryOptions = Partial<{
     with: Record<string, true | TDrizzleQueryOptions>;
     columns: Record<string, boolean>;
 }>;
-/**
- * Configuration for entity relationships.
- * Used to define one-to-one, one-to-many, and many-to-one relations.
- *
- * @property name - The relation name used in include queries
- * @property type - The relation type ('one' or 'many')
- * @property schema - The related entity's table schema
- * @property metadata - Drizzle relation metadata (fields, references)
- *
- * @example
- * ```typescript
- * const postsRelation: TRelationConfig = {
- *   name: 'posts',
- *   type: RelationTypes.MANY,
- *   schema: PostSchema,
- *   metadata: { fields: [Post.schema.authorId], references: [User.schema.id] }
- * };
- * ```
- */
+/** Configuration for entity relationships (one-to-one, one-to-many, many-to-one). */
 export type TRelationConfig = {
     name: string;
 } & ({
@@ -323,119 +87,44 @@ export type TRelationConfig = {
     schema: TTableSchemaWithId;
     metadata: Parameters<ReturnType<typeof createTableRelationsHelpers>[typeof RelationTypes.MANY]>[1];
 });
-/**
- * Configuration for repository operation logging.
- *
- * @property use - Whether to enable logging for this operation
- * @property level - The log level to use (defaults to 'info')
- */
+/** Configuration for repository operation logging. */
 export type TRepositoryLogOptions = {
     use: boolean;
     level?: TLogLevel;
 };
-/**
- * Interface for objects that can be associated with a database transaction.
- */
+/** Interface for objects that can be associated with a database transaction. */
 export interface IWithTransaction {
-    /** The active transaction to use for this operation. */
     transaction?: ITransaction;
 }
-/**
- * Extended options for repository operations.
- * Includes transaction support, logging configuration, and default filter bypass.
- *
- * @example
- * ```typescript
- * // Use with transaction
- * const tx = await repository.beginTransaction();
- * await repository.create({ data: user, options: { transaction: tx } });
- * await tx.commit();
- *
- * // Enable logging for debugging
- * await repository.find({ filter: {}, options: { log: { use: true, level: 'debug' } } });
- *
- * // Bypass default filter (e.g., soft delete)
- * await repository.find({ filter: {}, options: { shouldSkipDefaultFilter: true } });
- * ```
- */
+/** Extended options for repository operations with transaction, logging, and default filter bypass. */
 export interface IExtraOptions extends IWithTransaction {
-    /** Optional logging configuration for this operation. */
     log?: TRepositoryLogOptions;
-    /**
-     * If true, bypass the default filter configured in model settings.
-     * Use this when you need to query all records regardless of default filter constraints.
-     *
-     * @example
-     * ```typescript
-     * // Bypass default filter: { where: { isDeleted: false } }
-     * repository.find({ filter: {}, options: { shouldSkipDefaultFilter: true } });
-     * ```
-     */
+    /** If true, bypass the default filter configured in model settings (e.g., soft delete). */
     shouldSkipDefaultFilter?: boolean;
 }
-/**
- * @deprecated Use {@link IExtraOptions} instead.
- */
+/** @deprecated Use IExtraOptions instead. */
 export type TTransactionOption = IExtraOptions;
-/**
- * Base repository interface.
- * Defines the core properties and methods that all repositories must implement.
- *
- * @template EntitySchema - The Drizzle table schema type with an 'id' column
- */
+/** Base repository interface defining core properties and methods. */
 export interface IRepository<EntitySchema extends TTableSchemaWithId = TTableSchemaWithId> {
-    /** The data source providing database connectivity. */
     dataSource: IDataSource;
-    /** The entity/model instance associated with this repository. */
     entity: BaseEntity<EntitySchema>;
-    /** Returns the entity instance. */
     getEntity(): BaseEntity<EntitySchema>;
-    /** Returns the Drizzle table schema. */
     getEntitySchema(): EntitySchema;
-    /** Returns the database connector from the data source. */
     getConnector(): IDataSource['connector'];
 }
-/**
- * Interface for read-only repository operations.
- * Provides methods for querying data without modification capabilities.
- *
- * @template EntitySchema - The Drizzle table schema type
- * @template DataObject - The type of objects returned from queries
- * @template ExtraOptions - Additional options type extending IExtraOptions
- */
+/** Interface for read-only repository operations. */
 export interface IReadableRepository<EntitySchema extends TTableSchemaWithId = TTableSchemaWithId, DataObject extends TTableObject<EntitySchema> = TTableObject<EntitySchema>, ExtraOptions extends IExtraOptions = IExtraOptions> extends IRepository<EntitySchema> {
-    /**
-     * Builds Drizzle query options from a filter object.
-     * @param opts - Options containing the filter to convert
-     * @returns Drizzle-compatible query options
-     */
     buildQuery(opts: {
         filter: TFilter<DataObject>;
     }): TDrizzleQueryOptions;
-    /**
-     * Counts records matching the where condition.
-     * @param opts - Options containing where condition
-     * @returns Promise resolving to count result
-     */
     count(opts: {
         where: TWhere<DataObject>;
         options?: ExtraOptions;
     }): Promise<TCount>;
-    /**
-     * Checks if any records match the where condition.
-     * @param opts - Options containing where condition
-     * @returns Promise resolving to true if records exist
-     */
     existsWith(opts: {
         where: TWhere<DataObject>;
         options?: ExtraOptions;
     }): Promise<boolean>;
-    /**
-     * Finds all records matching the filter.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options containing filter and extra options with shouldQueryRange: true
-     * @returns Promise resolving to object with data array and range information
-     */
     find<R = DataObject>(opts: {
         filter: TFilter<DataObject>;
         options: ExtraOptions & {
@@ -445,55 +134,24 @@ export interface IReadableRepository<EntitySchema extends TTableSchemaWithId = T
         data: Array<R>;
         range: TDataRange;
     }>;
-    /**
-     * Finds all records matching the filter.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options containing filter and extra options
-     * @returns Promise resolving to array of matching records
-     */
     find<R = DataObject>(opts: {
         filter: TFilter<DataObject>;
         options?: ExtraOptions & {
             shouldQueryRange?: false;
         };
     }): Promise<Array<R>>;
-    /**
-     * Finds the first record matching the filter.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options containing filter and extra options
-     * @returns Promise resolving to the found record or null
-     */
     findOne<R = DataObject>(opts: {
         filter: TFilter<DataObject>;
         options?: ExtraOptions;
     }): Promise<TNullable<R>>;
-    /**
-     * Finds a record by its ID.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options containing id and optional filter (without where)
-     * @returns Promise resolving to the found record or null
-     */
     findById<R = DataObject>(opts: {
         id: IdType;
         filter?: Omit<TFilter<DataObject>, 'where'>;
         options?: ExtraOptions;
     }): Promise<TNullable<R>>;
 }
-/**
- * Interface for full CRUD repository operations.
- * Extends IReadableRepository with create, update, and delete capabilities.
- *
- * @template EntitySchema - The Drizzle table schema type
- * @template DataObject - The type of objects returned from queries
- * @template PersistObject - The type for insert/update operations
- * @template ExtraOptions - Additional options type extending IExtraOptions
- */
+/** Interface for full CRUD repository operations. */
 export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId = TTableSchemaWithId, DataObject extends TTableObject<EntitySchema> = TTableObject<EntitySchema>, PersistObject extends TTableInsert<EntitySchema> = TTableInsert<EntitySchema>, ExtraOptions extends IExtraOptions = IExtraOptions> extends IReadableRepository<EntitySchema, DataObject, ExtraOptions> {
-    /**
-     * Creates a single record.
-     * @param opts - Options with data and shouldReturn: false
-     * @returns Promise with count only (no data returned)
-     */
     create(opts: {
         data: PersistObject;
         options: ExtraOptions & {
@@ -502,12 +160,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Creates a single record and returns it.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with data to create
-     * @returns Promise with count and created record
-     */
     create<R = DataObject>(opts: {
         data: PersistObject;
         options?: ExtraOptions & {
@@ -516,11 +168,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: R;
     }>;
-    /**
-     * Creates multiple records in bulk.
-     * @param opts - Options with data array and shouldReturn: false
-     * @returns Promise with count only
-     */
     createAll(opts: {
         data: Array<PersistObject>;
         options: ExtraOptions & {
@@ -529,12 +176,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Creates multiple records and returns them.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with data array
-     * @returns Promise with count and created records
-     */
     createAll<R = DataObject>(opts: {
         data: Array<PersistObject>;
         options?: ExtraOptions & {
@@ -543,11 +184,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: Array<R>;
     }>;
-    /**
-     * Updates a record by its ID.
-     * @param opts - Options with id, partial data, and shouldReturn: false
-     * @returns Promise with count only
-     */
     updateById(opts: {
         id: IdType;
         data: Partial<PersistObject>;
@@ -557,12 +193,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Updates a record by its ID and returns it.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with id and partial data
-     * @returns Promise with count and updated record
-     */
     updateById<R = DataObject>(opts: {
         id: IdType;
         data: Partial<PersistObject>;
@@ -572,11 +202,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: R;
     }>;
-    /**
-     * Updates all records matching the where condition.
-     * @param opts - Options with data, where, and shouldReturn: false
-     * @returns Promise with count only
-     */
     updateAll(opts: {
         data: Partial<PersistObject>;
         where: TWhere<DataObject>;
@@ -587,12 +212,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Updates all records matching the where condition and returns them.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with data and where condition
-     * @returns Promise with count and updated records
-     */
     updateAll<R = DataObject>(opts: {
         data: Partial<PersistObject>;
         where: TWhere<DataObject>;
@@ -603,11 +222,7 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: Array<R>;
     }>;
-    /**
-     * Alias for updateAll. Updates records matching the where condition.
-     * @param opts - Options with data, where, and shouldReturn: false
-     * @returns Promise with count only
-     */
+    /** Alias for updateAll. */
     updateBy(opts: {
         data: Partial<PersistObject>;
         where: TWhere<DataObject>;
@@ -618,12 +233,7 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Alias for updateAll. Updates records and returns them.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with data and where condition
-     * @returns Promise with count and updated records
-     */
+    /** Alias for updateAll. */
     updateBy<R = DataObject>(opts: {
         data: Partial<PersistObject>;
         where: TWhere<DataObject>;
@@ -634,11 +244,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: Array<R>;
     }>;
-    /**
-     * Deletes a record by its ID.
-     * @param opts - Options with id and shouldReturn: false
-     * @returns Promise with count only
-     */
     deleteById(opts: {
         id: IdType;
         options: ExtraOptions & {
@@ -647,12 +252,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Deletes a record by its ID and returns it.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with id
-     * @returns Promise with count and deleted record
-     */
     deleteById<R = DataObject>(opts: {
         id: IdType;
         options?: ExtraOptions & {
@@ -661,11 +260,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: R;
     }>;
-    /**
-     * Deletes all records matching the where condition.
-     * @param opts - Options with where and shouldReturn: false
-     * @returns Promise with count only
-     */
     deleteAll(opts: {
         where?: TWhere<DataObject>;
         options: ExtraOptions & {
@@ -675,12 +269,6 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Deletes all records matching the where condition and returns them.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with where condition
-     * @returns Promise with count and deleted records
-     */
     deleteAll<R = DataObject>(opts: {
         where?: TWhere<DataObject>;
         options?: ExtraOptions & {
@@ -690,11 +278,7 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: Array<R>;
     }>;
-    /**
-     * Alias for deleteAll. Deletes records matching the where condition.
-     * @param opts - Options with where and shouldReturn: false
-     * @returns Promise with count only
-     */
+    /** Alias for deleteAll. */
     deleteBy(opts: {
         where?: TWhere<DataObject>;
         options: ExtraOptions & {
@@ -704,12 +288,7 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
     }): Promise<TCount & {
         data: undefined | null;
     }>;
-    /**
-     * Alias for deleteAll. Deletes records and returns them.
-     * @template R - Return type (defaults to DataObject)
-     * @param opts - Options with where condition
-     * @returns Promise with count and deleted records
-     */
+    /** Alias for deleteAll. */
     deleteBy<R = DataObject>(opts: {
         where?: TWhere<DataObject>;
         options?: ExtraOptions & {
@@ -720,15 +299,7 @@ export interface IPersistableRepository<EntitySchema extends TTableSchemaWithId
         data: Array<R>;
     }>;
 }
-/**
- * Options passed to query operator handler functions.
- * Used internally by {@link QueryOperators} to build SQL conditions.
- *
- * @template T - The type of the comparison value
- *
- * @property column - The Drizzle column to compare against
- * @property value - The value to compare with
- */
+/** Options passed to query operator handler functions. */
 export interface IQueryHandlerOptions<T = any> {
     column: Column;
     value: T;