@simplysm/orm-common 13.0.68 → 13.0.70

package/dist/exec/queryable.d.ts

@@ -8,110 +8,110 @@ import type { ColumnPrimitive } from "../types/column";
 import type { WhereExprUnit, ExprInput } from "../expr/expr-unit";
 import { ExprUnit } from "../expr/expr-unit";
 /**
- * JOIN 쿼리 빌더
+ * JOIN query builder
  *
- * join/joinSingle 메서드 내부에서 사용되며, 조인 대상 테이블을 지정하는 역할을 수행
+ * Used internally by join/joinSingle methods to specify the table to join
  */
 declare class JoinQueryable {
     private readonly _db;
     private readonly _joinAlias;
     constructor(_db: DbContextBase, _joinAlias: string);
     /**
-     * 조인할 테이블을 지정
+     * Specify the table to join
      *
-     * @param table - 조인 대상 테이블
-     * @returns 조인된 Queryable
+     * @param table - Table to join
+     * @returns Joined Queryable
      */
     from<T extends TableBuilder<any, any>>(table: T): Queryable<T["$infer"], T>;
     /**
-     * 조인 결과의 컬럼을 직접 지정
+     * Directly specify columns in join result
      *
-     * @param columns - 커스텀 컬럼 정의
-     * @returns 커스텀 컬럼이 적용된 Queryable
+     * @param columns - Custom column definition
+     * @returns Queryable with custom columns applied
      */
     select<R extends DataRecord>(columns: QueryableRecord<R>): Queryable<R, never>;
     /**
-     * 여러 Queryable을 UNION으로 결합
+     * Combine multiple Queryables with UNION
      *
-     * @param queries - UNION할 Queryable 배열 (최소 2개)
-     * @returns UNION된 Queryable
-     * @throws 2개 미만의 queryable이 전달된 경우
+     * @param queries - Array of Queryables to UNION (minimum 2)
+     * @returns UNION-ed Queryable
+     * @throws If less than 2 queryables are passed
      */
     union<TData extends DataRecord>(...queries: Queryable<TData, any>[]): Queryable<TData, never>;
 }
 /**
- * 재귀 CTE(Common Table Expression) 빌더
+ * Recursive CTE (Common Table Expression) builder
  *
- * recursive() 메서드 내부에서 사용되며, 재귀 쿼리의 본문을 정의하는 역할을 수행
+ * used internally in recursive() method, Defines the body of a recursive query
  *
- * @template TBaseData - 기본 쿼리의 데이터 타입
+ * @template TBaseData - Base query data type
  */
 declare class RecursiveQueryable<TBaseData extends DataRecord> {
     private readonly _baseQr;
     private readonly _cteName;
     constructor(_baseQr: Queryable<TBaseData, any>, _cteName: string);
     /**
-     * 재귀 쿼리의 대상 테이블을 지정
+     * specify the target table for recursive query
      *
-     * @param table - 재귀할 대상 테이블
-     * @returns self 속성이 추가된 Queryable (자기 참조용)
+     * @param table - Target table to recurse
+     * @returns Queryable with self property added (for self-reference)
      */
     from<T extends TableBuilder<any, any>>(table: T): Queryable<T["$infer"] & {
         self?: TBaseData[];
     }, T>;
     /**
-     * 재귀 쿼리의 컬럼을 직접 지정
+     * Directly specify columns in recursive query
      *
-     * @param columns - 커스텀 컬럼 정의
-     * @returns self 속성이 추가된 Queryable
+     * @param columns - Custom column definition
+     * @returns Queryable with self property added
      */
     select<R extends DataRecord>(columns: QueryableRecord<R>): Queryable<R & {
         self?: TBaseData[];
     }, never>;
     /**
-     * 여러 Queryable을 UNION으로 결합 (재귀 쿼리용)
+     * Combine multiple Queryables with UNION (for recursive query)
      *
-     * @param queries - UNION할 Queryable 배열 (최소 2개)
-     * @returns self 속성이 추가된 UNION Queryable
-     * @throws 2개 미만의 queryable이 전달된 경우
+     * @param queries - Array of Queryables to UNION (minimum 2)
+     * @returns UNION Queryable with self property added
+     * @throws If less than 2 queryables are passed
      */
     union<TData extends DataRecord>(...queries: Queryable<TData, any>[]): Queryable<TData & {
         self?: TBaseData[];
     }, never>;
 }
 /**
- * 쿼리 빌더 클래스
+ * Query builder class
  *
- * 테이블/뷰에 대한 SELECT, INSERT, UPDATE, DELETE 등의 쿼리를 체이닝 방식으로 구성
+ * Construct SELECT, INSERT, UPDATE, DELETE queries on tables/views in a chaining manner
  *
- * @template TData - 쿼리 결과의 데이터 타입
- * @template TFrom - 원본 테이블 (CUD 작업에 필요)
+ * @template TData - Data type of query result
+ * @template TFrom - Source table (needed for CUD operations)
  *
  * @example
  * ```typescript
- * // 기본 조회
+ * // Basic query
  * const users = await db.user()
  *   .where((u) => [expr.eq(u.isActive, true)])
  *   .orderBy((u) => u.name)
  *   .result();
  *
- * // JOIN 조회
+ * // JOIN query
  * const posts = await db.post()
  *   .include((p) => p.user)
  *   .result();
  *
  * // INSERT
- * await db.user().insert([{ name: "홍길동", email: "test@test.com" }]);
+ * await db.user().insert([{ name: "Gildong Hong", email: "test@test.com" }]);
  * ```
  */
 export declare class Queryable<TData extends DataRecord, TFrom extends TableBuilder<any, any> | never> {
     readonly meta: QueryableMeta<TData>;
     constructor(meta: QueryableMeta<TData>);
     /**
-     * SELECT할 컬럼을 지정합니다.
+     * Specify columns to SELECT.
      *
-     * @param fn - 컬럼 매핑 함수. 원본 컬럼을 받아 새 컬럼 구조를 반환
-     * @returns 새로운 컬럼 구조가 적용된 Queryable
+     * @param fn - Column mapping function. Receives original columns and returns new column structure
+     * @returns Queryable with new column structure applied
      *
      * @example
      * ```typescript
@@ -123,9 +123,9 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     select<R extends Record<string, any>>(fn: (columns: QueryableRecord<TData>) => R): Queryable<UnwrapQueryableRecord<R>, never>;
     /**
-     * DISTINCT 옵션을 적용하여 중복 행을 제거
+     * Apply DISTINCT option to remove duplicate rows
      *
-     * @returns DISTINCT가 적용된 Queryable
+     * @returns Queryable with DISTINCT applied
      *
      * @example
      * ```typescript
@@ -136,11 +136,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     distinct(): Queryable<TData, never>;
     /**
-     * 행 잠금(FOR UPDATE)을 적용
+     * Apply row lock (FOR UPDATE)
      *
-     * 트랜잭션 내에서 선택된 행에 대한 배타적 잠금을 획득
+     * Acquire exclusive lock on selected rows within transaction
      *
-     * @returns 잠금이 적용된 Queryable
+     * @returns Queryable with lock applied
      *
      * @example
      * ```typescript
@@ -154,14 +154,14 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     lock(): Queryable<TData, TFrom>;
     /**
-     * 상위 N개의 행만 조회 (ORDER BY 없이 사용 가능)
+     * Select only top N rows (can be used without ORDER BY)
      *
-     * @param count - 조회할 행 수
-     * @returns TOP이 적용된 Queryable
+     * @param count - number of rows to select
+     * @returns Queryable with TOP applied
      *
      * @example
      * ```typescript
-     * // 최신 사용자 10명
+     * // Latest 10 users
      * db.user()
      *   .orderBy((u) => u.createdAt, "DESC")
      *   .top(10)
@@ -169,28 +169,28 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     top(count: number): Queryable<TData, TFrom>;
     /**
-     * 페이지네이션을 위한 LIMIT/OFFSET을 설정합니다.
-     * 반드시 orderBy()를 먼저 호출해야 합니다.
+     * Set LIMIT/OFFSET for pagination.
+     * Must call orderBy() first.
      *
-     * @param skip - 건너뛸 행 수 (OFFSET)
-     * @param take - 가져올 행 수 (LIMIT)
-     * @returns 페이지네이션이 적용된 Queryable
-     * @throws ORDER BY 절이 없으면 에러
+     * @param skip - number of rows to skip (OFFSET)
+     * @param take - number of rows to fetch (LIMIT)
+     * @returns Queryable with pagination applied
+     * @throws Error if no ORDER BY clause
      *
      * @example
      * ```typescript
      * db.user
      *   .orderBy((u) => u.createdAt)
-     *   .limit(0, 20) // 첫 20개
+     *   .limit(0, 20) // first 20
      * ```
      */
     limit(skip: number, take: number): Queryable<TData, TFrom>;
     /**
-     * 정렬 조건을 추가합니다. 여러 번 호출하면 순서대로 적용됩니다.
+     * Add sorting condition. Multiple calls apply in order.
      *
-     * @param fn - 정렬 기준 컬럼을 반환하는 함수
-     * @param orderBy - 정렬 방향 (ASC/DESC). 기본값: ASC
-     * @returns 정렬 조건이 추가된 Queryable
+     * @param fn - function returning columns to sort by
+     * @param orderBy - Sort direction (ASC/DESC). Default: ASC
+     * @returns sorting 조건이 추가된 Queryable
      *
      * @example
      * ```typescript
@@ -201,9 +201,9 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     orderBy(fn: (columns: QueryableRecord<TData>) => ExprUnit<ColumnPrimitive>, orderBy?: "ASC" | "DESC"): Queryable<TData, TFrom>;
     /**
-     * WHERE 조건을 추가합니다. 여러 번 호출하면 AND로 결합됩니다.
+     * WHERE condition을 추가합니다. 여러 번 호출하면 AND로 결합됩니다.
      *
-     * @param predicate - 조건 배열을 반환하는 함수
+     * @param predicate - Condition 배열을 반환하는 function
      * @returns 조건이 추가된 Queryable
      *
      * @example
@@ -218,26 +218,26 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      * 텍스트 검색을 수행
      *
      * 검색 문법은 {@link parseSearchQuery}를 참조
-     * - 공백으로 구분된 단어는 OR 조건
-     * - `+`로 시작하는 단어는 필수 포함 (AND 조건)
-     * - `-`로 시작하는 단어는 제외 (NOT 조건)
+     * - 공백으로 구분된 단어는 OR condition
+     * - `+`로 시작하는 단어는 required include (AND Condition)
+     * - `-`로 시작하는 단어는 exclude (NOT Condition)
      *
-     * @param fn - 검색 대상 컬럼을 반환하는 함수
+     * @param fn - 검색 대상 column을 반환하는 function
      * @param searchText - 검색 텍스트
      * @returns 검색 조건이 추가된 Queryable
      *
      * @example
      * ```typescript
      * db.user()
-     *   .search((u) => [u.name, u.email], "홍길동 -탈퇴")
+     *   .search((u) => [u.name, u.email], "Gildong Hong -탈퇴")
      * ```
      */
     search(fn: (columns: QueryableRecord<TData>) => ExprUnit<string | undefined>[], searchText: string): Queryable<TData, TFrom>;
     /**
-     * GROUP BY 절을 추가
+     * GROUP BY 절을 Add
      *
-     * @param fn - 그룹화 기준 컬럼을 반환하는 함수
-     * @returns GROUP BY가 적용된 Queryable
+     * @param fn - Group화 기준 column을 반환하는 function
+     * @returns Queryable with GROUP BY applied
      *
      * @example
      * ```typescript
@@ -251,10 +251,10 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     groupBy(fn: (columns: QueryableRecord<TData>) => ExprUnit<ColumnPrimitive>[]): Queryable<TData, never>;
     /**
-     * HAVING 절을 추가 (GROUP BY 후 필터링)
+     * HAVING 절을 Add (GROUP BY 후 filtering)
      *
-     * @param predicate - 조건 배열을 반환하는 함수
-     * @returns HAVING이 적용된 Queryable
+     * @param predicate - Condition 배열을 반환하는 function
+     * @returns HAVING이 apply된 Queryable
      *
      * @example
      * ```typescript
@@ -269,11 +269,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     having(predicate: (columns: QueryableRecord<TData>) => WhereExprUnit[]): Queryable<TData, never>;
     /**
-     * 1:N 관계의 LEFT OUTER JOIN을 수행 (배열로 결과 추가)
+     * 1:N 관계의 LEFT OUTER JOIN을 수행 (배열로 result Add)
      *
-     * @param as - 결과에 추가할 속성 이름
-     * @param fwd - 조인 조건을 정의하는 콜백 함수
-     * @returns 조인 결과가 배열로 추가된 Queryable
+     * @param as - Result에 추가할 property 이름
+     * @param fwd - Join 조건을 정의하는 콜백 function
+     * @returns join 결과가 배열로 추가된 Queryable
      *
      * @example
      * ```typescript
@@ -282,18 +282,18 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      *     qr.from(Post)
      *       .where((p) => [expr.eq(p.userId, u.id)])
      *   )
-     * // 결과: { id, name, posts: [{ id, title }, ...] }
+     * // Result: { id, name, posts: [{ id, title }, ...] }
      * ```
      */
     join<A extends string, R extends DataRecord>(as: A, fwd: (qr: JoinQueryable, cols: QueryableRecord<TData>) => Queryable<R, any>): Queryable<TData & {
         [K in A]?: R[];
     }, TFrom>;
     /**
-     * N:1 또는 1:1 관계의 LEFT OUTER JOIN을 수행 (단일 객체로 결과 추가)
+     * N:1 또는 1:1 관계의 LEFT OUTER JOIN을 수행 (단일 객체로 result Add)
      *
-     * @param as - 결과에 추가할 속성 이름
-     * @param fwd - 조인 조건을 정의하는 콜백 함수
-     * @returns 조인 결과가 단일 객체로 추가된 Queryable
+     * @param as - Result에 추가할 property 이름
+     * @param fwd - Join 조건을 정의하는 콜백 function
+     * @returns join 결과가 단일 객체로 추가된 Queryable
      *
      * @example
      * ```typescript
@@ -302,7 +302,7 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      *     qr.from(User)
      *       .where((u) => [expr.eq(u.id, p.userId)])
      *   )
-     * // 결과: { id, title, user: { id, name } | undefined }
+     * // Result: { id, title, user: { id, name } | undefined }
      * ```
      */
     joinSingle<A extends string, R extends DataRecord>(as: A, fwd: (qr: JoinQueryable, cols: QueryableRecord<TData>) => Queryable<R, any>): Queryable<{
@@ -311,22 +311,22 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
         [K in A]?: R;
     }, TFrom>;
     /**
-     * 관계된 테이블을 자동으로 JOIN합니다.
+     * 관계된 Table을 automatic으로 JOIN합니다.
      * TableBuilder에 정의된 FK/FKT 관계를 기반으로 동작합니다.
      *
-     * @param fn - 포함할 관계를 선택하는 함수 (PathProxy를 통해 타입 체크됨)
+     * @param fn - 포함할 관계를 선택하는 function (PathProxy를 통해 type 체크됨)
      * @returns JOIN이 추가된 Queryable
      * @throws 관계가 정의되지 않은 경우 에러
      *
      * @example
      * ```typescript
-     * // 단일 관계 포함
+     * // 단일 relationship include
      * db.post.include((p) => p.user)
      *
-     * // 중첩 관계 포함
+     * // 중첩 relationship include
      * db.post.include((p) => p.user.company)
      *
-     * // 다중 관계 포함
+     * // 다중 relationship include
      * db.user
      *   .include((u) => u.company)
      *   .include((u) => u.posts)
@@ -335,11 +335,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     include(fn: (item: PathProxy<TData>) => PathProxy<any>): Queryable<TData, TFrom>;
     private _include;
     /**
-     * 현재 Queryable을 서브쿼리로 감싸기
+     * 현재 Queryable을 Subquery로 감싸기
      *
      * distinct() 또는 groupBy() 후 count() 사용 시 필요
      *
-     * @returns 서브쿼리로 감싸진 Queryable
+     * @returns Subquery로 감싸진 Queryable
      *
      * @example
      * ```typescript
@@ -353,11 +353,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     wrap(): Queryable<TData, never>;
     /**
-     * 여러 Queryable을 UNION으로 결합 (중복 제거)
+     * Combine multiple Queryables with UNION (remove duplicates)
      *
-     * @param queries - UNION할 Queryable 배열 (최소 2개)
-     * @returns UNION된 Queryable
-     * @throws 2개 미만의 queryable이 전달된 경우
+     * @param queries - Array of Queryables to UNION (minimum 2)
+     * @returns UNION-ed Queryable
+     * @throws If less than 2 queryables are passed
      *
      * @example
      * ```typescript
@@ -369,12 +369,12 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     static union<TData extends DataRecord>(...queries: Queryable<TData, any>[]): Queryable<TData, never>;
     /**
-     * 재귀 CTE(Common Table Expression)를 생성
+     * recursive CTE(Common Table Expression)를 Generate
      *
-     * 계층 구조 데이터(조직도, 카테고리 트리 등)를 조회할 때 사용
+     * 계층 structure data(조직도, 카테고리 트리 등)를 조회할 때 사용
      *
-     * @param fwd - 재귀 부분을 정의하는 콜백 함수
-     * @returns 재귀 CTE가 적용된 Queryable
+     * @param fwd - recursive part을 정의하는 콜백 function
+     * @returns recursive CTE가 apply된 Queryable
      *
      * @example
      * ```typescript
@@ -389,9 +389,9 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     recursive(fwd: (qr: RecursiveQueryable<TData>) => Queryable<TData, any>): Queryable<TData, never>;
     /**
-     * SELECT 쿼리를 실행하고 결과 배열을 반환
+     * SELECT query를 실행하고 result 배열을 return
      *
-     * @returns 쿼리 결과 배열
+     * @returns Query result array
      *
      * @example
      * ```typescript
@@ -402,9 +402,9 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     result(): Promise<TData[]>;
     /**
-     * 단일 결과를 반환 (2개 이상이면 에러)
+     * 단일 결과를 return (2개 이상이면 Error)
      *
-     * @returns 단일 결과 또는 undefined
+     * @returns 단일 result 또는 undefined
      * @throws 2개 이상의 결과가 반환된 경우
      *
      * @example
@@ -416,13 +416,13 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     single(): Promise<TData | undefined>;
     /**
-     * 쿼리 소스 이름 반환 (에러 메시지용)
+     * query 소스 이름 return (error message용)
      */
     private _getSourceName;
     /**
-     * 첫 번째 결과를 반환 (여러 개여도 첫 번째만)
+     * 첫 번째 결과를 return (여러 개여도 첫 번째만)
      *
-     * @returns 첫 번째 결과 또는 undefined
+     * @returns 첫 번째 result 또는 undefined
      *
      * @example
      * ```typescript
@@ -433,10 +433,10 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     first(): Promise<TData | undefined>;
     /**
-     * 결과 행 수를 반환
+     * result row 수를 return
      *
-     * @param fwd - 카운트할 컬럼을 지정하는 함수 (선택)
-     * @returns 행 수
+     * @param fwd - 카운트할 column을 지정하는 function (Select)
+     * @returns row 수
      * @throws distinct() 또는 groupBy() 후 직접 호출 시 에러 (wrap() 필요)
      *
      * @example
@@ -448,7 +448,7 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      */
     count(fwd?: (cols: QueryableRecord<TData>) => ExprUnit<ColumnPrimitive>): Promise<number>;
     /**
-     * 조건에 맞는 데이터 존재 여부를 확인
+     * 조건에 맞는 data 존재 여부를 확인
      *
      * @returns 존재하면 true, 없으면 false
      *
@@ -466,24 +466,24 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     private _buildJoinDefs;
     getResultMeta(outputColumns?: string[]): ResultMeta;
     /**
-     * INSERT 쿼리를 실행
+     * INSERT query를 실행
      *
-     * MSSQL의 1000개 제한을 위해 자동으로 1000개씩 청크로 분할하여 실행
+     * MSSQL의 1000개 제한을 위해 automatic으로 1000개씩 청크로 분할하여 실행
      *
-     * @param records - 삽입할 레코드 배열
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 삽입된 레코드 배열 반환
+     * @param records - Insert할 레코드 array
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 삽입된 레코드 array return
      *
      * @example
      * ```typescript
      * // 단순 삽입
      * await db.user().insert([
-     *   { name: "홍길동", email: "hong@test.com" },
+     *   { name: "Gildong Hong", email: "hong@test.com" },
      * ]);
      *
-     * // 삽입 후 ID 반환
+     * // 삽입 후 ID return
      * const [inserted] = await db.user().insert(
-     *   [{ name: "홍길동" }],
+     *   [{ name: "Gildong Hong" }],
      *   ["id"],
      * );
      * ```
@@ -491,27 +491,27 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     insert(records: TFrom["$inferInsert"][]): Promise<void>;
     insert<K extends keyof TFrom["$inferColumns"] & string>(records: TFrom["$inferInsert"][], outputColumns: K[]): Promise<Pick<TFrom["$inferColumns"], K>[]>;
     /**
-     * WHERE 조건에 맞는 데이터가 없으면 INSERT
+     * WHERE condition에 맞는 data가 없으면 INSERT
      *
-     * @param record - 삽입할 레코드
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 삽입된 레코드 반환
+     * @param record - Insert할 레코드
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 삽입된 레코드 return
      *
      * @example
      * ```typescript
      * await db.user()
      *   .where((u) => [expr.eq(u.email, "test@test.com")])
-     *   .insertIfNotExists({ name: "테스트", email: "test@test.com" });
+     *   .insertIfNotExists({ name: "testing", email: "test@test.com" });
      * ```
      */
     insertIfNotExists(record: TFrom["$inferInsert"]): Promise<void>;
     insertIfNotExists<K extends keyof TFrom["$inferColumns"] & string>(record: TFrom["$inferInsert"], outputColumns: K[]): Promise<Pick<TFrom["$inferColumns"], K>>;
     /**
-     * INSERT INTO ... SELECT (현재 SELECT 결과를 다른 테이블에 INSERT)
+     * INSERT INTO ... SELECT (현재 SELECT 결과를 다른 Table에 INSERT)
      *
-     * @param targetTable - 삽입 대상 테이블
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 삽입된 레코드 배열 반환
+     * @param targetTable - Insert 대상 Table
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 삽입된 레코드 array return
      *
      * @example
      * ```typescript
@@ -527,11 +527,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     getInsertIfNotExistsQueryDef(record: TFrom["$inferInsert"], outputColumns?: (keyof TFrom["$inferColumns"] & string)[]): InsertIfNotExistsQueryDef;
     getInsertIntoQueryDef<TTable extends TableBuilder<DataToColumnBuilderRecord<TData>, any>>(targetTable: TTable, outputColumns?: (keyof TTable["$inferColumns"] & string)[]): InsertIntoQueryDef;
     /**
-     * UPDATE 쿼리를 실행
+     * UPDATE query를 실행
      *
-     * @param recordFwd - 업데이트할 컬럼과 값을 반환하는 함수
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 업데이트된 레코드 배열 반환
+     * @param recordFwd - Update할 column과 값을 반환하는 function
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 업데이트된 레코드 array return
      *
      * @example
      * ```typescript
@@ -539,11 +539,11 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
      * await db.user()
      *   .where((u) => [expr.eq(u.id, 1)])
      *   .update((u) => ({
-     *     name: expr.val("string", "새이름"),
+     *     name: expr.val("string", "New Name"),
      *     updatedAt: expr.val("DateTime", DateTime.now()),
      *   }));
      *
-     * // 기존 값 참조
+     * // 기존 value 참조
      * await db.product()
      *   .update((p) => ({
      *     price: expr.mul(p.price, expr.val("number", 1.1)),
@@ -553,19 +553,19 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     update(recordFwd: (cols: QueryableRecord<TData>) => QueryableWriteRecord<TFrom["$inferUpdate"]>): Promise<void>;
     update<K extends keyof TFrom["$columns"] & string>(recordFwd: (cols: QueryableRecord<TData>) => QueryableWriteRecord<TFrom["$inferUpdate"]>, outputColumns: K[]): Promise<Pick<TFrom["$columns"], K>[]>;
     /**
-     * DELETE 쿼리를 실행
+     * DELETE query를 실행
      *
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 삭제된 레코드 배열 반환
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 삭제된 레코드 array return
      *
      * @example
      * ```typescript
-     * // 단순 삭제
+     * // 단순 Delete
      * await db.user()
      *   .where((u) => [expr.eq(u.id, 1)])
      *   .delete();
      *
-     * // 삭제된 데이터 반환
+     * // 삭제된 data return
      * const deleted = await db.user()
      *   .where((u) => [expr.eq(u.isExpired, true)])
      *   .delete(["id", "name"]);
@@ -576,26 +576,26 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     getUpdateQueryDef(recordFwd: (cols: QueryableRecord<TData>) => QueryableWriteRecord<TFrom["$inferUpdate"]>, outputColumns?: (keyof TFrom["$inferColumns"] & string)[]): UpdateQueryDef;
     getDeleteQueryDef(outputColumns?: (keyof TFrom["$inferColumns"] & string)[]): DeleteQueryDef;
     /**
-     * UPSERT (UPDATE or INSERT) 쿼리를 실행
+     * UPSERT (UPDATE or INSERT) query를 실행
      *
-     * WHERE 조건에 맞는 데이터가 있으면 UPDATE, 없으면 INSERT
+     * WHERE condition에 맞는 data가 있으면 UPDATE, 없으면 INSERT
      *
-     * @param updateFwd - 업데이트할 컬럼과 값을 반환하는 함수
-     * @param insertFwd - 삽입할 레코드를 반환하는 함수 (선택, 미지정 시 updateFwd와 동일)
-     * @param outputColumns - 반환받을 컬럼 이름 배열 (선택)
-     * @returns outputColumns 지정 시 영향받은 레코드 배열 반환
+     * @param updateFwd - Update할 column과 값을 반환하는 function
+     * @param insertFwd - Insert할 레코드를 반환하는 function (selection, 미지정 시 updateFwd와 동일)
+     * @param outputColumns - column name array to receive (Select)
+     * @returns outputColumns 지정 시 영향받은 레코드 array return
      *
      * @example
      * ```typescript
-     * // UPDATE/INSERT 동일 데이터
+     * // UPDATE/INSERT 동일 data
      * await db.user()
      *   .where((u) => [expr.eq(u.email, "test@test.com")])
      *   .upsert(() => ({
-     *     name: expr.val("string", "테스트"),
+     *     name: expr.val("string", "testing"),
      *     email: expr.val("string", "test@test.com"),
      *   }));
      *
-     * // UPDATE/INSERT 다른 데이터
+     * // UPDATE/INSERT 다른 data
      * await db.user()
      *   .where((u) => [expr.eq(u.email, "test@test.com")])
      *   .upsert(
@@ -610,18 +610,18 @@ export declare class Queryable<TData extends DataRecord, TFrom extends TableBuil
     upsert<U extends QueryableWriteRecord<TFrom["$inferUpdate"]>, K extends keyof TFrom["$inferColumns"] & string>(updateFwd: (cols: QueryableRecord<TData>) => U, insertFwd: (updateRecord: U) => QueryableWriteRecord<TFrom["$inferInsert"]>, outputColumns?: K[]): Promise<Pick<TFrom["$inferColumns"], K>[]>;
     getUpsertQueryDef<U extends QueryableWriteRecord<TFrom["$inferUpdate"]>>(updateRecordFwd: (cols: QueryableRecord<TData>) => U, insertRecordFwd: (updateRecord: U) => QueryableWriteRecord<TFrom["$inferInsert"]>, outputColumns?: (keyof TFrom["$inferColumns"] & string)[]): UpsertQueryDef;
     /**
-     * FK 제약조건 on/off (트랜잭션 내 사용 가능)
+     * FK constraint on/off (transaction 내 사용 가능)
      */
     switchFk(switch_: "on" | "off"): Promise<void>;
     private _getCudOutputDef;
 }
 /**
- * FK 컬럼 배열과 대상 테이블의 PK를 매칭하여 PK 컬럼명 배열을 반환
+ * FK column 배열과 대상 Table의 PK를 매칭하여 PK column명 배열을 return
  *
- * @param fkCols - FK 컬럼명 배열
- * @param targetTable - 참조 대상 테이블 빌더
- * @returns 매칭된 PK 컬럼명 배열
- * @throws FK/PK 컬럼 수 불일치 시
+ * @param fkCols - FK column명 array
+ * @param targetTable - 참조 대상 Table builder
+ * @returns 매칭된 PK column명 array
+ * @throws FK/PK column 수 불일치 시
  */
 export declare function getMatchedPrimaryKeys(fkCols: string[], targetTable: TableBuilder<any, any>): string[];
 interface QueryableMeta<TData extends DataRecord> {
@@ -659,20 +659,20 @@ export type NullableQueryableRecord<TData extends DataRecord> = {
     [K in keyof TData]: TData[K] extends ColumnPrimitive ? ExprUnit<TData[K] | undefined> : TData[K] extends (infer U)[] ? U extends DataRecord ? NullableQueryableRecord<U>[] : never : TData[K] extends (infer U)[] | undefined ? U extends DataRecord ? NullableQueryableRecord<U>[] | undefined : never : TData[K] extends DataRecord ? NullableQueryableRecord<TData[K]> : TData[K] extends DataRecord | undefined ? NullableQueryableRecord<Exclude<TData[K], undefined>> | undefined : never;
 };
 /**
- * QueryableRecord에서 DataRecord로 역변환
+ * QueryableRecord에서 DataRecord로 역transform
  *
- * ExprUnit<T>를 T로, 중첩 객체/배열을 재귀적으로 풀어냄
+ * ExprUnit<T>를 T로, 중첩 object/배열을 재귀적으로 풀어냄
  */
 export type UnwrapQueryableRecord<R> = {
     [K in keyof R]: R[K] extends ExprUnit<infer T> ? T : NonNullable<R[K]> extends (infer U)[] ? U extends Record<string, any> ? UnwrapQueryableRecord<U>[] | Extract<R[K], undefined> : never : NonNullable<R[K]> extends Record<string, any> ? UnwrapQueryableRecord<NonNullable<R[K]>> | Extract<R[K], undefined> : never;
 };
 /**
- * include()에서 관계 경로를 타입 안전하게 지정하기 위한 Proxy 타입
- * ColumnPrimitive가 아닌 필드(FK, FKT 관계)만 접근 가능
+ * include()에서 relationship 경로를 type 안전하게 지정하기 위한 Proxy type
+ * ColumnPrimitive가 아닌 필드(FK, FKT relationship)만 access 가능
  *
  * @example
  * ```typescript
- * // item.user.company 접근 시 내부적으로 ["user", "company"] 경로 수집
+ * // item.user.company access 시 내부적으로 ["user", "company"] 경로 수집
  * db.post.include(item => item.user.company)
  *
  * // item.title은 string(ColumnPrimitive)이므로 컴파일 에러
@@ -680,12 +680,12 @@ export type UnwrapQueryableRecord<R> = {
  * ```
  */
 /**
- * 배열이면 요소 타입 추출
+ * 배열이면 요소 type 추출
  */
 type UnwrapArray<TArray> = TArray extends (infer TElement)[] ? TElement : TArray;
 declare const PATH_SYMBOL: unique symbol;
 /**
- * include()용 타입 안전 경로 프록시
+ * include()용 type 안전 경로 프록시
  */
 export type PathProxy<TObject> = {
     [K in keyof TObject as TObject[K] extends ColumnPrimitive ? never : K]-?: PathProxy<UnwrapArray<TObject[K]>>;
@@ -693,14 +693,14 @@ export type PathProxy<TObject> = {
     readonly [PATH_SYMBOL]: string[];
 };
 /**
- * 테이블 또는 뷰에 대한 Queryable 팩토리 함수를 생성
+ * Table 또는 View에 대한 Queryable factory 함수를 Generate
  *
- * DbContext에서 테이블/뷰별 getter를 정의할 때 사용
+ * DbContext에서 Table/View별 getter를 정의할 때 사용
  *
- * @param db - DbContext 인스턴스
- * @param tableOrView - TableBuilder 또는 ViewBuilder 인스턴스
- * @param as - alias 지정 (선택, 미지정 시 자동 생성)
- * @returns Queryable을 반환하는 팩토리 함수
+ * @param db - DbContext instance
+ * @param tableOrView - TableBuilder 또는 ViewBuilder instance
+ * @param as - alias 지정 (selection, 미지정 시 automatic Create)
+ * @returns Queryable을 반환하는 factory function
  *
  * @example
  * ```typescript