@simplysm/orm-common 13.0.69 → 13.0.70

package/dist/expr/expr.d.ts

@@ -10,114 +10,114 @@ interface WinSpecInput {
     orderBy?: [ExprInput<ColumnPrimitive>, ("ASC" | "DESC")?][];
 }
 /**
- * Switch 표현식 빌더 인터페이스
+ * Switch expression builder interface
  */
 export interface SwitchExprBuilder<TPrimitive extends ColumnPrimitive> {
     case(condition: WhereExprUnit, then: ExprInput<TPrimitive>): SwitchExprBuilder<TPrimitive>;
     default(value: ExprInput<TPrimitive>): ExprUnit<TPrimitive>;
 }
 /**
- * Dialect 독립적인 SQL 표현식 빌더
+ * Dialect-independent SQL expression builder
  *
- * SQL 문자열이 아닌 JSON AST(Expr)를 생성하여, QueryBuilder가
- * 각 DBMS(MySQL, MSSQL, PostgreSQL)에 맞게 변환
+ * Generates JSON AST (Expr) instead of SQL strings, which QueryBuilder
+ * converts to each DBMS (MySQL, MSSQL, PostgreSQL)
  *
  * @example
  * ```typescript
- * // WHERE 조건
+ * // WHERE condition
  * db.user().where((u) => [
  *   expr.eq(u.status, "active"),
  *   expr.gt(u.age, 18),
  * ])
  *
- * // SELECT 표현식
+ * // SELECT expression
  * db.user().select((u) => ({
  *   name: expr.concat(u.firstName, " ", u.lastName),
  *   age: expr.dateDiff("year", u.birthDate, expr.val("DateOnly", DateOnly.today())),
  * }))
  *
- * // 집계 함수
+ * // Aggregate function
  * db.order().groupBy((o) => o.userId).select((o) => ({
  *   userId: o.userId,
  *   total: expr.sum(o.amount),
  * }))
  * ```
  *
- * @see {@link Queryable} 쿼리 빌더 클래스
- * @see {@link ExprUnit} 표현식 래퍼 클래스
+ * @see {@link Queryable} Query builder class
+ * @see {@link ExprUnit} Expression wrapper class
  */
 export declare const expr: {
     /**
-     * 리터럴 값을 ExprUnit으로 래핑
+     * Wrap literal value as ExprUnit
      *
-     * dataType에 맞는 base 타입으로 widening하여 리터럴 타입 제거
+     * Widen to base type matching dataType, remove literal type
      *
-     * @param dataType - 값의 데이터 타입 ("string", "number", "boolean", "DateTime", "DateOnly", "Time", "Uuid", "Buffer")
-     * @param value - 래핑할 값 (undefined 허용)
-     * @returns 래핑된 ExprUnit 인스턴스
+     * @param dataType - Value의 data type ("string", "number", "boolean", "DateTime", "DateOnly", "Time", "Uuid", "Buffer")
+     * @param value - 래핑할 value (undefined allow)
+     * @returns 래핑된 ExprUnit instance
      *
      * @example
      * ```typescript
-     * // 문자열 값
+     * // String value
      * expr.val("string", "active")
      *
-     * // 숫자 값
+     * // Number value
      * expr.val("number", 100)
      *
-     * // 날짜 값
+     * // Date value
      * expr.val("DateOnly", DateOnly.today())
      *
-     * // undefined 값
+     * // undefined value
      * expr.val("string", undefined)
      * ```
      */
     val<TStr extends ColumnPrimitiveStr, T extends ColumnPrimitiveMap[TStr] | undefined>(dataType: TStr, value: T): ExprUnit<T extends undefined ? ColumnPrimitiveMap[TStr] | undefined : ColumnPrimitiveMap[TStr]>;
     /**
-     * 컬럼 참조를 생성
+     * Generate column reference
      *
-     * 일반적으로 Queryable 콜백 내 프록시 객체를 사용하므로 직접 호출할 일이 적음
+     * Typically proxy objects are used inside Queryable callbacks
      *
-     * @param dataType - 컬럼의 데이터 타입
-     * @param path - 컬럼 경로 (테이블 alias, 컬럼명 등)
-     * @returns 컬럼 참조 ExprUnit 인스턴스
+     * @param dataType - Column data type
+     * @param path - Column path (table alias, column name, etc.)
+     * @returns Column reference ExprUnit instance
      *
      * @example
      * ```typescript
-     * // 직접 컬럼 참조 (내부용)
+     * // Direct column reference (internal use)
      * expr.col("string", "T1", "name")
      * ```
      */
     col<TStr extends ColumnPrimitiveStr>(dataType: ColumnPrimitiveStr, ...path: string[]): ExprUnit<ColumnPrimitiveMap[TStr] | undefined>;
     /**
-     * Raw SQL 표현식 생성 (escape hatch)
+     * Raw SQL expression Generate (escape hatch)
      *
-     * ORM에서 지원하지 않는 DB별 함수나 문법을 직접 사용할 때 사용.
-     * 태그 템플릿 리터럴 형식으로 사용하며, 보간된 값은 자동으로 파라미터화됨
+     * Use when you need to directly use DB-specific functions or syntax not supported by the ORM.
+     * Used as tagged template literal, interpolated values are automatically parameterized
      *
-     * @param dataType - 반환될 값의 데이터 타입
-     * @returns 태그 템플릿 함수
+     * @param dataType - Data type of the returned value
+     * @returns Tagged template function
      *
      * @example
      * ```typescript
-     * // MySQL JSON 함수 사용
+     * // Using MySQL JSON function
      * db.user().select((u) => ({
      *   name: u.name,
      *   data: expr.raw("string")`JSON_EXTRACT(${u.metadata}, '$.email')`,
      * }))
      *
-     * // PostgreSQL 배열 함수
+     * // PostgreSQL array function
      * expr.raw("number")`ARRAY_LENGTH(${u.tags}, 1)`
      * ```
      */
     raw<T extends ColumnPrimitiveStr>(dataType: T): (strings: TemplateStringsArray, ...values: ExprInput<ColumnPrimitive>[]) => ExprUnit<ColumnPrimitiveMap[T] | undefined>;
     /**
-     * 동등 비교 (NULL-safe)
+     * Equality comparison (NULL-safe)
      *
-     * NULL 값도 안전하게 비교 (MySQL: `<=>`, MSSQL/PostgreSQL: `IS NULL OR =`)
+     * Safely compare even NULL values (MySQL: `<=>`, MSSQL/PostgreSQL: `IS NULL OR =`)
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param target - 비교 대상 값 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param target - Target value or expression for comparison
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -127,11 +127,11 @@ export declare const expr: {
      */
     eq<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit;
     /**
-     * 초과 비교 (>)
+     * Greater than comparison (>)
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param target - 비교 대상 값 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param target - Target value or expression for comparison
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -141,11 +141,11 @@ export declare const expr: {
      */
     gt<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit;
     /**
-     * 미만 비교 (<)
+     * Less than comparison (<)
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param target - 비교 대상 값 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param target - Target value or expression for comparison
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -155,11 +155,11 @@ export declare const expr: {
      */
     lt<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit;
     /**
-     * 이상 비교 (>=)
+     * Greater than or equal comparison (>=)
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param target - 비교 대상 값 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param target - Target value or expression for comparison
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -169,11 +169,11 @@ export declare const expr: {
      */
     gte<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit;
     /**
-     * 이하 비교 (<=)
+     * Less than or equal comparison (<=)
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param target - 비교 대상 값 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param target - Target value or expression for comparison
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -183,22 +183,22 @@ export declare const expr: {
      */
     lte<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit;
     /**
-     * 범위 비교 (BETWEEN)
+     * range comparison (BETWEEN)
      *
      * from/to가 undefined이면 해당 방향은 무제한
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param from - 시작 값 (undefined이면 하한 없음)
-     * @param to - 끝 값 (undefined이면 상한 없음)
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param from - start value (undefined이면 하한 N/A)
+     * @param to - 끝 value (undefined이면 상한 N/A)
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
-     * // 범위 지정
+     * // range 지정
      * db.user().where((u) => [expr.between(u.age, 18, 65)])
      * // WHERE age BETWEEN 18 AND 65
      *
-     * // 하한만 지정
+     * // Specify only lower bound
      * db.user().where((u) => [expr.between(u.age, 18, undefined)])
      * // WHERE age >= 18
      * ```
@@ -207,8 +207,8 @@ export declare const expr: {
     /**
      * NULL 체크 (IS NULL)
      *
-     * @param source - 체크할 컬럼 또는 표현식
-     * @returns WHERE 조건 표현식
+     * @param source - 체크할 column 또는 expression
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -218,14 +218,14 @@ export declare const expr: {
      */
     null<T extends ColumnPrimitive>(source: ExprUnit<T>): WhereExprUnit;
     /**
-     * LIKE 패턴 매칭
+     * LIKE pattern 매칭
      *
      * `%`는 0개 이상의 문자, `_`는 단일 문자와 매칭.
-     * 특수문자는 `\`로 이스케이프됨
+     * 특수문자는 `\`로 escape됨
      *
-     * @param source - 검색할 컬럼 또는 표현식
-     * @param pattern - 검색 패턴 (%, _ 와일드카드 사용 가능)
-     * @returns WHERE 조건 표현식
+     * @param source - 검색할 column 또는 expression
+     * @param pattern - 검색 pattern (%, _ wildcard 사용 가능)
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -233,19 +233,19 @@ export declare const expr: {
      * db.user().where((u) => [expr.like(u.name, "John%")])
      * // WHERE name LIKE 'John%' ESCAPE '\'
      *
-     * // 포함 검색
+     * // include 검색
      * db.user().where((u) => [expr.like(u.email, "%@gmail.com")])
      * ```
      */
     like(source: ExprUnit<string | undefined>, pattern: ExprInput<string | undefined>): WhereExprUnit;
     /**
-     * 정규식 패턴 매칭
+     * regular expression pattern 매칭
      *
-     * DBMS별 정규식 문법 차이 주의 필요
+     * DBMS별 regular expression 문법 차이 주의 필요
      *
-     * @param source - 검색할 컬럼 또는 표현식
-     * @param pattern - 정규식 패턴
-     * @returns WHERE 조건 표현식
+     * @param source - 검색할 column 또는 expression
+     * @param pattern - regular expression pattern
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -255,11 +255,11 @@ export declare const expr: {
      */
     regexp(source: ExprUnit<string | undefined>, pattern: ExprInput<string | undefined>): WhereExprUnit;
     /**
-     * IN 연산자 - 값 목록과 비교
+     * IN operator - Value 목록과 comparison
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param values - 비교할 값 목록
-     * @returns WHERE 조건 표현식
+     * @param source - Column or expression to compare
+     * @param values - 비교할 value 목록
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -269,14 +269,14 @@ export declare const expr: {
      */
     in<T extends ColumnPrimitive>(source: ExprUnit<T>, values: ExprInput<T>[]): WhereExprUnit;
     /**
-     * IN (SELECT ...) - 서브쿼리 결과와 비교
+     * IN (SELECT ...) - Subquery 결과와 comparison
      *
-     * 서브쿼리는 반드시 단일 컬럼만 SELECT해야 함
+     * Subquery는 반드시 단일 column만 SELECT해야 함
      *
-     * @param source - 비교할 컬럼 또는 표현식
-     * @param query - 단일 컬럼을 반환하는 Queryable
-     * @returns WHERE 조건 표현식
-     * @throws {Error} 서브쿼리가 단일 컬럼이 아닌 경우
+     * @param source - Column or expression to compare
+     * @param query - 단일 column을 반환하는 Queryable
+     * @returns WHERE condition expression
+     * @throws {Error} Subquery가 단일 column이 아닌 경우
      *
      * @example
      * ```typescript
@@ -293,12 +293,12 @@ export declare const expr: {
      */
     inQuery<T extends ColumnPrimitive, TData extends Record<string, T>>(source: ExprUnit<T>, query: Queryable<TData, any>): WhereExprUnit;
     /**
-     * EXISTS (SELECT ...) - 서브쿼리 결과 존재 여부 확인
+     * EXISTS (SELECT ...) - Subquery result 존재 여부 확인
      *
-     * 서브쿼리가 하나 이상의 행을 반환하면 true
+     * Subquery가 하나 이상의 행을 반환하면 true
      *
      * @param query - 존재 여부를 확인할 Queryable
-     * @returns WHERE 조건 표현식
+     * @returns WHERE condition expression
      *
      * @example
      * ```typescript
@@ -313,10 +313,10 @@ export declare const expr: {
      */
     exists(query: Queryable<any, any>): WhereExprUnit;
     /**
-     * NOT 연산자 - 조건 부정
+     * NOT operator - Condition 부정
      *
-     * @param arg - 부정할 조건
-     * @returns 부정된 WHERE 조건 표현식
+     * @param arg - 부정할 condition
+     * @returns 부정된 WHERE condition expression
      *
      * @example
      * ```typescript
@@ -326,12 +326,12 @@ export declare const expr: {
      */
     not(arg: WhereExprUnit): WhereExprUnit;
     /**
-     * AND 연산자 - 모든 조건 충족
+     * AND operator - 모든 condition 충족
      *
-     * 여러 조건을 AND로 결합. where() 메서드에 배열로 전달하면 자동으로 AND 적용됨
+     * 여러 조건을 AND로 결합. where() 메서드에 배열로 전달하면 automatic으로 AND applied
      *
-     * @param conditions - AND로 결합할 조건 목록
-     * @returns 결합된 WHERE 조건 표현식
+     * @param conditions - AND로 결합할 condition 목록
+     * @returns 결합된 WHERE condition expression
      *
      * @example
      * ```typescript
@@ -346,10 +346,10 @@ export declare const expr: {
      */
     and(conditions: WhereExprUnit[]): WhereExprUnit;
     /**
-     * OR 연산자 - 하나 이상의 조건 충족
+     * OR operator - 하나 이상의 condition 충족
      *
-     * @param conditions - OR로 결합할 조건 목록
-     * @returns 결합된 WHERE 조건 표현식
+     * @param conditions - OR로 결합할 condition 목록
+     * @returns 결합된 WHERE condition expression
      *
      * @example
      * ```typescript
@@ -366,10 +366,10 @@ export declare const expr: {
     /**
      * 문자열 연결 (CONCAT)
      *
-     * NULL 값은 빈 문자열로 처리됨 (DBMS별 자동 변환)
+     * NULL 값은 빈 문자열로 processing됨 (DBMS별 automatic Transform)
      *
      * @param args - 연결할 문자열들
-     * @returns 연결된 문자열 표현식
+     * @returns 연결된 문자열 expression
      *
      * @example
      * ```typescript
@@ -383,9 +383,9 @@ export declare const expr: {
     /**
      * 문자열 왼쪽에서 지정 길이만큼 추출 (LEFT)
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @param length - 추출할 문자 수
-     * @returns 추출된 문자열 표현식
+     * @returns 추출된 문자열 expression
      *
      * @example
      * ```typescript
@@ -399,9 +399,9 @@ export declare const expr: {
     /**
      * 문자열 오른쪽에서 지정 길이만큼 추출 (RIGHT)
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @param length - 추출할 문자 수
-     * @returns 추출된 문자열 표현식
+     * @returns 추출된 문자열 expression
      *
      * @example
      * ```typescript
@@ -413,10 +413,10 @@ export declare const expr: {
      */
     right<T extends string | undefined>(source: ExprUnit<T>, length: ExprInput<number>): ExprUnit<T>;
     /**
-     * 문자열 양쪽 공백 제거 (TRIM)
+     * 문자열 양쪽 공백 Remove (TRIM)
      *
-     * @param source - 원본 문자열
-     * @returns 공백이 제거된 문자열 표현식
+     * @param source - original string
+     * @returns 공백이 제거된 문자열 expression
      *
      * @example
      * ```typescript
@@ -430,12 +430,12 @@ export declare const expr: {
     /**
      * 문자열 왼쪽 패딩 (LPAD)
      *
-     * 지정 길이가 될 때까지 왼쪽에 fillString 반복 추가
+     * 지정 길이가 될 때까지 왼쪽에 fillString loop Add
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @param length - 목표 길이
      * @param fillString - 패딩에 사용할 문자열
-     * @returns 패딩된 문자열 표현식
+     * @returns 패딩된 문자열 expression
      *
      * @example
      * ```typescript
@@ -443,17 +443,17 @@ export declare const expr: {
      *   orderNo: expr.padStart(expr.cast(o.id, { type: "varchar", length: 10 }), 8, "0"),
      * }))
      * // SELECT LPAD(CAST(id AS VARCHAR(10)), 8, '0') AS orderNo
-     * // 결과: "00000123"
+     * // Result: "00000123"
      * ```
      */
     padStart<T extends string | undefined>(source: ExprUnit<T>, length: ExprInput<number>, fillString: ExprInput<string>): ExprUnit<T>;
     /**
      * 문자열 치환 (REPLACE)
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @param from - 찾을 문자열
      * @param to - 대체할 문자열
-     * @returns 치환된 문자열 표현식
+     * @returns 치환된 문자열 expression
      *
      * @example
      * ```typescript
@@ -465,10 +465,10 @@ export declare const expr: {
      */
     replace<T extends string | undefined>(source: ExprUnit<T>, from: ExprInput<string>, to: ExprInput<string>): ExprUnit<T>;
     /**
-     * 문자열 대문자 변환 (UPPER)
+     * 문자열 대문자 Transform (UPPER)
      *
-     * @param source - 원본 문자열
-     * @returns 대문자로 변환된 문자열 표현식
+     * @param source - original string
+     * @returns 대문자로 Transform된 문자열 expression
      *
      * @example
      * ```typescript
@@ -480,10 +480,10 @@ export declare const expr: {
      */
     upper<T extends string | undefined>(source: ExprUnit<T>): ExprUnit<T>;
     /**
-     * 문자열 소문자 변환 (LOWER)
+     * 문자열 소문자 Transform (LOWER)
      *
-     * @param source - 원본 문자열
-     * @returns 소문자로 변환된 문자열 표현식
+     * @param source - original string
+     * @returns 소문자로 Transform된 문자열 expression
      *
      * @example
      * ```typescript
@@ -497,7 +497,7 @@ export declare const expr: {
     /**
      * 문자열 길이 (문자 수)
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @returns 문자 수
      *
      * @example
@@ -514,7 +514,7 @@ export declare const expr: {
      *
      * UTF-8 환경에서 한글은 3바이트
      *
-     * @param source - 원본 문자열
+     * @param source - original string
      * @returns 바이트 수
      *
      * @example
@@ -531,15 +531,15 @@ export declare const expr: {
      *
      * SQL 표준에 따라 1-based index 사용
      *
-     * @param source - 원본 문자열
-     * @param start - 시작 위치 (1부터 시작)
+     * @param source - original string
+     * @param start - start 위치 (1부터 start)
      * @param length - 추출할 길이 (생략 시 끝까지)
-     * @returns 추출된 문자열 표현식
+     * @returns 추출된 문자열 expression
      *
      * @example
      * ```typescript
      * db.user().select((u) => ({
-     *   // "Hello World"에서 인덱스 1부터 5글자: "Hello"
+     *   // "Hello World"에서 Index 1부터 5글자: "Hello"
      *   prefix: expr.substring(u.name, 1, 5),
      * }))
      * // SELECT SUBSTRING(name, 1, 5) AS prefix
@@ -549,11 +549,11 @@ export declare const expr: {
     /**
      * 문자열 내 위치 찾기 (LOCATE/CHARINDEX)
      *
-     * 1-based index 반환, 없으면 0 반환
+     * 1-based index return, 없으면 0 return
      *
      * @param source - 검색할 문자열
      * @param search - 찾을 문자열
-     * @returns 위치 (1부터 시작, 없으면 0)
+     * @returns 위치 (1부터 start, 없으면 0)
      *
      * @example
      * ```typescript
@@ -568,8 +568,8 @@ export declare const expr: {
     /**
      * 절대값 (ABS)
      *
-     * @param source - 원본 숫자
-     * @returns 절대값 표현식
+     * @param source - 원본 Number
+     * @returns 절대값 expression
      *
      * @example
      * ```typescript
@@ -583,9 +583,9 @@ export declare const expr: {
     /**
      * 반올림 (ROUND)
      *
-     * @param source - 원본 숫자
+     * @param source - 원본 Number
      * @param digits - 소수점 이하 자릿수
-     * @returns 반올림된 숫자 표현식
+     * @returns 반올림된 Number expression
      *
      * @example
      * ```typescript
@@ -600,8 +600,8 @@ export declare const expr: {
     /**
      * 올림 (CEILING)
      *
-     * @param source - 원본 숫자
-     * @returns 올림된 숫자 표현식
+     * @param source - 원본 Number
+     * @returns 올림된 Number expression
      *
      * @example
      * ```typescript
@@ -616,8 +616,8 @@ export declare const expr: {
     /**
      * 버림 (FLOOR)
      *
-     * @param source - 원본 숫자
-     * @returns 버림된 숫자 표현식
+     * @param source - 원본 Number
+     * @returns 버림된 Number expression
      *
      * @example
      * ```typescript
@@ -632,8 +632,8 @@ export declare const expr: {
     /**
      * 연도 추출 (YEAR)
      *
-     * @param source - DateTime 또는 DateOnly 표현식
-     * @returns 연도 (4자리 숫자)
+     * @param source - DateTime 또는 DateOnly expression
+     * @returns 연도 (4자리 Number)
      *
      * @example
      * ```typescript
@@ -647,7 +647,7 @@ export declare const expr: {
     /**
      * 월 추출 (MONTH)
      *
-     * @param source - DateTime 또는 DateOnly 표현식
+     * @param source - DateTime 또는 DateOnly expression
      * @returns 월 (1~12)
      *
      * @example
@@ -662,7 +662,7 @@ export declare const expr: {
     /**
      * 일 추출 (DAY)
      *
-     * @param source - DateTime 또는 DateOnly 표현식
+     * @param source - DateTime 또는 DateOnly expression
      * @returns 일 (1~31)
      *
      * @example
@@ -677,7 +677,7 @@ export declare const expr: {
     /**
      * 시 추출 (HOUR)
      *
-     * @param source - DateTime 또는 Time 표현식
+     * @param source - DateTime 또는 Time expression
      * @returns 시 (0~23)
      *
      * @example
@@ -692,7 +692,7 @@ export declare const expr: {
     /**
      * 분 추출 (MINUTE)
      *
-     * @param source - DateTime 또는 Time 표현식
+     * @param source - DateTime 또는 Time expression
      * @returns 분 (0~59)
      *
      * @example
@@ -707,7 +707,7 @@ export declare const expr: {
     /**
      * 초 추출 (SECOND)
      *
-     * @param source - DateTime 또는 Time 표현식
+     * @param source - DateTime 또는 Time expression
      * @returns 초 (0~59)
      *
      * @example
@@ -722,9 +722,9 @@ export declare const expr: {
     /**
      * ISO 주차 추출
      *
-     * ISO 8601 기준 주차 (월요일 시작, 1~53)
+     * ISO 8601 기준 주차 (월요일 start, 1~53)
      *
-     * @param source - DateOnly 표현식
+     * @param source - DateOnly expression
      * @returns ISO 주차 번호
      *
      * @example
@@ -739,10 +739,10 @@ export declare const expr: {
     /**
      * ISO 주 시작일 (월요일)
      *
-     * 해당 날짜가 속한 주의 월요일 반환
+     * 해당 Date가 속한 주의 월요일 return
      *
-     * @param source - DateOnly 표현식
-     * @returns 주의 시작 날짜 (월요일)
+     * @param source - DateOnly expression
+     * @returns 주의 start Date (월요일)
      *
      * @example
      * ```typescript
@@ -756,9 +756,9 @@ export declare const expr: {
     /**
      * ISO 연월 (해당 월의 1일)
      *
-     * 해당 날짜의 월 첫째 날 반환
+     * 해당 Date의 월 첫째 날 return
      *
-     * @param source - DateOnly 표현식
+     * @param source - DateOnly expression
      * @returns 월의 첫째 날
      *
      * @example
@@ -771,12 +771,12 @@ export declare const expr: {
      */
     isoYearMonth<T extends DateOnly | undefined>(source: ExprUnit<T>): ExprUnit<T>;
     /**
-     * 날짜 차이 계산 (DATEDIFF)
+     * Date 차이 계산 (DATEDIFF)
      *
      * @param separator - 단위 ("year", "month", "day", "hour", "minute", "second")
-     * @param from - 시작 날짜
-     * @param to - 끝 날짜
-     * @returns 차이 값 (to - from)
+     * @param from - start Date
+     * @param to - 끝 Date
+     * @returns 차이 value (to - from)
      *
      * @example
      * ```typescript
@@ -788,12 +788,12 @@ export declare const expr: {
      */
     dateDiff<T extends DateTime | DateOnly | Time | undefined>(separator: DateSeparator, from: ExprInput<T>, to: ExprInput<T>): ExprUnit<T extends undefined ? undefined : number>;
     /**
-     * 날짜 더하기 (DATEADD)
+     * Date 더하기 (DATEADD)
      *
      * @param separator - 단위 ("year", "month", "day", "hour", "minute", "second")
-     * @param source - 원본 날짜
-     * @param value - 더할 값 (음수 가능)
-     * @returns 계산된 날짜
+     * @param source - 원본 Date
+     * @param value - 더할 value (음수 가능)
+     * @returns 계산된 Date
      *
      * @example
      * ```typescript
@@ -805,13 +805,13 @@ export declare const expr: {
      */
     dateAdd<T extends DateTime | DateOnly | Time | undefined>(separator: DateSeparator, source: ExprUnit<T>, value: ExprInput<number>): ExprUnit<T>;
     /**
-     * 날짜 포맷 (DATE_FORMAT)
+     * Date 포맷 (DATE_FORMAT)
      *
      * DBMS별로 포맷 문자열 규칙이 다를 수 있음
      *
-     * @param source - 날짜 표현식
+     * @param source - Date expression
      * @param format - 포맷 문자열 (예: "%Y-%m-%d")
-     * @returns 포맷된 문자열 표현식
+     * @returns 포맷된 문자열 expression
      *
      * @example
      * ```typescript
@@ -826,10 +826,10 @@ export declare const expr: {
     /**
      * NULL 대체 (COALESCE/IFNULL)
      *
-     * 첫 번째 non-null 값을 반환. 마지막 인자가 non-nullable이면 결과도 non-nullable
+     * 첫 번째 non-null 값을 return. 마지막 인자가 non-nullable이면 결과도 non-nullable
      *
-     * @param args - 검사할 값들 (마지막은 기본값)
-     * @returns 첫 번째 non-null 값
+     * @param args - Inspect할 값들 (마지막은 Default value)
+     * @returns 첫 번째 non-null value
      *
      * @example
      * ```typescript
@@ -841,18 +841,18 @@ export declare const expr: {
      */
     ifNull: typeof ifNull;
     /**
-     * 특정 값이면 NULL 반환 (NULLIF)
+     * 특정 값이면 NULL return (NULLIF)
      *
-     * source === value 이면 NULL 반환, 아니면 source 반환
+     * source === value 이면 NULL return, 아니면 source return
      *
-     * @param source - 원본 값
-     * @param value - 비교할 값
-     * @returns NULL 또는 원본 값
+     * @param source - 원본 value
+     * @param value - 비교할 value
+     * @returns NULL 또는 원본 value
      *
      * @example
      * ```typescript
      * db.user().select((u) => ({
-     *   // 빈 문자열을 NULL로 변환
+     *   // 빈 문자열을 NULL로 Transform
      *   bio: expr.nullIf(u.bio, ""),
      * }))
      * // SELECT NULLIF(bio, '') AS bio
@@ -860,12 +860,12 @@ export declare const expr: {
      */
     nullIf<T extends ColumnPrimitive>(source: ExprUnit<T>, value: ExprInput<T>): ExprUnit<T | undefined>;
     /**
-     * WHERE 표현식을 boolean으로 변환
+     * WHERE 표현식을 boolean으로 Transform
      *
-     * SELECT 절에서 조건 결과를 boolean 컬럼으로 사용할 때 사용
+     * SELECT 절에서 condition 결과를 boolean column으로 사용할 때 사용
      *
-     * @param condition - 변환할 조건
-     * @returns boolean 표현식
+     * @param condition - Transform할 condition
+     * @returns boolean expression
      *
      * @example
      * ```typescript
@@ -877,11 +877,11 @@ export declare const expr: {
      */
     is(condition: WhereExprUnit): ExprUnit<boolean>;
     /**
-     * CASE WHEN 표현식 빌더
+     * CASE WHEN expression builder
      *
-     * 체이닝 방식으로 조건 분기를 구성
+     * 체이닝 방식으로 condition 분기를 구성
      *
-     * @returns SwitchExprBuilder 인스턴스
+     * @returns SwitchExprBuilder instance
      *
      * @example
      * ```typescript
@@ -897,12 +897,12 @@ export declare const expr: {
      */
     switch<T extends ColumnPrimitive>(): SwitchExprBuilder<T>;
     /**
-     * 단순 IF 조건 (삼항 연산자)
+     * 단순 IF condition (삼항 operator)
      *
-     * @param condition - 조건
-     * @param then - 조건이 참일 때 값
-     * @param else_ - 조건이 거짓일 때 값
-     * @returns 조건부 값 표현식
+     * @param condition - Condition
+     * @param then - Condition이 참일 때 value
+     * @param else_ - Condition이 거짓일 때 value
+     * @returns 조건부 value expression
      *
      * @example
      * ```typescript
@@ -914,18 +914,18 @@ export declare const expr: {
      */
     if<T extends ColumnPrimitive>(condition: WhereExprUnit, then: ExprInput<T>, else_: ExprInput<T>): ExprUnit<T>;
     /**
-     * 행 수 카운트 (COUNT)
+     * row 수 카운트 (COUNT)
      *
-     * @param arg - 카운트할 컬럼 (생략 시 전체 행 수)
-     * @param distinct - true면 중복 제거
-     * @returns 행 수
+     * @param arg - 카운트할 column (생략 시 전체 row 수)
+     * @param distinct - true면 중복 Remove
+     * @returns row 수
      *
      * @example
      * ```typescript
-     * // 전체 행 수
+     * // 전체 row 수
      * db.user().select(() => ({ total: expr.count() }))
      *
-     * // 중복 제거 카운트
+     * // 중복 Remove 카운트
      * db.order().select((o) => ({
      *   uniqueCustomers: expr.count(o.customerId, true),
      * }))
@@ -935,9 +935,9 @@ export declare const expr: {
     /**
      * 합계 (SUM)
      *
-     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
      *
-     * @param arg - 합계를 구할 숫자 컬럼
+     * @param arg - 합계를 구할 Number column
      * @returns 합계 (또는 NULL)
      *
      * @example
@@ -952,9 +952,9 @@ export declare const expr: {
     /**
      * 평균 (AVG)
      *
-     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
      *
-     * @param arg - 평균을 구할 숫자 컬럼
+     * @param arg - 평균을 구할 Number column
      * @returns 평균 (또는 NULL)
      *
      * @example
@@ -969,9 +969,9 @@ export declare const expr: {
     /**
      * 최대값 (MAX)
      *
-     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
      *
-     * @param arg - 최대값을 구할 컬럼
+     * @param arg - 최대값을 구할 column
      * @returns 최대값 (또는 NULL)
      *
      * @example
@@ -986,9 +986,9 @@ export declare const expr: {
     /**
      * 최소값 (MIN)
      *
-     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+     * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
      *
-     * @param arg - 최소값을 구할 컬럼
+     * @param arg - 최소값을 구할 column
      * @returns 최소값 (또는 NULL)
      *
      * @example
@@ -1001,7 +1001,7 @@ export declare const expr: {
      */
     min<T extends ColumnPrimitive>(arg: ExprUnit<T>): ExprUnit<T | undefined>;
     /**
-     * 여러 값 중 최대값 (GREATEST)
+     * 여러 value 중 최대값 (GREATEST)
      *
      * @param args - 비교할 값들
      * @returns 최대값
@@ -1016,7 +1016,7 @@ export declare const expr: {
      */
     greatest<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T>;
     /**
-     * 여러 값 중 최소값 (LEAST)
+     * 여러 value 중 최소값 (LEAST)
      *
      * @param args - 비교할 값들
      * @returns 최소값
@@ -1031,9 +1031,9 @@ export declare const expr: {
      */
     least<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T>;
     /**
-     * 행 번호 (ROW_NUMBER 없이 전체 행에 대한 순번)
+     * row 번호 (ROW_NUMBER 없이 전체 행에 대한 순번)
      *
-     * @returns 행 번호 (1부터 시작)
+     * @returns row 번호 (1부터 start)
      *
      * @example
      * ```typescript
@@ -1045,25 +1045,25 @@ export declare const expr: {
      */
     rowNum(): ExprUnit<number>;
     /**
-     * 난수 생성 (RAND/RANDOM)
+     * 난수 Generate (RAND/RANDOM)
      *
-     * 0~1 사이의 난수 반환. ORDER BY에서 랜덤 정렬용으로 주로 사용
+     * 0~1 사이의 난수 return. ORDER BY에서 랜덤 정렬용으로 주로 사용
      *
      * @returns 0~1 사이의 난수
      *
      * @example
      * ```typescript
-     * // 랜덤 정렬
+     * // 랜덤 sorting
      * db.user().orderBy(() => expr.random()).limit(10)
      * ```
      */
     random(): ExprUnit<number>;
     /**
-     * 타입 변환 (CAST)
+     * type transformation (CAST)
      *
-     * @param source - 변환할 표현식
-     * @param targetType - 대상 데이터 타입
-     * @returns 변환된 표현식
+     * @param source - Transform할 expression
+     * @param targetType - 대상 data type
+     * @returns Transform된 expression
      *
      * @example
      * ```typescript
@@ -1075,13 +1075,13 @@ export declare const expr: {
      */
     cast<T extends ColumnPrimitive, TDataType extends DataType>(source: ExprUnit<T>, targetType: TDataType): ExprUnit<T extends undefined ? undefined : InferColumnPrimitiveFromDataType<TDataType>>;
     /**
-     * 스칼라 서브쿼리 - SELECT 절에서 단일 값 반환 서브쿼리
+     * 스칼라 Subquery - SELECT 절에서 단일 value return Subquery
      *
-     * 서브쿼리는 반드시 단일 행, 단일 컬럼을 반환해야 함
+     * Subquery는 반드시 단일 row, 단일 column을 반환해야 함
      *
-     * @param dataType - 반환될 값의 데이터 타입
+     * @param dataType - Data type of the returned value
      * @param queryable - 스칼라 값을 반환하는 Queryable
-     * @returns 서브쿼리 결과 표현식
+     * @returns Subquery result expression
      *
      * @example
      * ```typescript
@@ -1101,12 +1101,12 @@ export declare const expr: {
         getSelectQueryDef(): SelectQueryDef;
     }): ExprUnit<ColumnPrimitiveMap[TStr] | undefined>;
     /**
-     * ROW_NUMBER() - 파티션 내 행 번호
+     * ROW_NUMBER() - 파티션 내 row 번호
      *
-     * 각 파티션 내에서 1부터 시작하는 순차 번호 부여
+     * 각 파티션 내에서 1부터 시작하는 sequential 번호 부여
      *
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 행 번호 (1부터 시작)
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns row 번호 (1부터 start)
      *
      * @example
      * ```typescript
@@ -1124,7 +1124,7 @@ export declare const expr: {
     /**
      * RANK() - 파티션 내 순위 (동점 시 같은 순위, 다음 순위 건너뜀)
      *
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+     * @param spec - Window spec (partitionBy, orderBy)
      * @returns 순위 (동점 후 건너뜀: 1, 1, 3)
      *
      * @example
@@ -1141,7 +1141,7 @@ export declare const expr: {
     /**
      * DENSE_RANK() - 파티션 내 밀집 순위 (동점 시 같은 순위, 다음 순위 유지)
      *
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+     * @param spec - Window spec (partitionBy, orderBy)
      * @returns 밀집 순위 (동점 후 연속: 1, 1, 2)
      *
      * @example
@@ -1156,15 +1156,15 @@ export declare const expr: {
      */
     denseRank(spec: WinSpecInput): ExprUnit<number>;
     /**
-     * NTILE(n) - 파티션을 n개 그룹으로 분할
+     * NTILE(n) - 파티션을 n개 그룹으로 split
      *
      * @param n - 분할할 그룹 수
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+     * @param spec - Window spec (partitionBy, orderBy)
      * @returns 그룹 번호 (1 ~ n)
      *
      * @example
      * ```typescript
-     * // 상위 25%를 찾기 위한 사분위 분할
+     * // 상위 25%를 찾기 위한 사분위 split
      * db.user().select((u) => ({
      *   name: u.name,
      *   quartile: expr.ntile(4, {
@@ -1175,12 +1175,12 @@ export declare const expr: {
      */
     ntile(n: number, spec: WinSpecInput): ExprUnit<number>;
     /**
-     * LAG() - 이전 행의 값 참조
+     * LAG() - 이전 행의 value 참조
      *
-     * @param column - 참조할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @param options - offset (기본 1), default (이전 행이 없을 때 기본값)
-     * @returns 이전 행의 값 (또는 기본값/NULL)
+     * @param column - column to reference
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @param options - offset (Basic 1), default (이전 행이 없을 때 Default value)
+     * @returns 이전 행의 value (또는 Default value/NULL)
      *
      * @example
      * ```typescript
@@ -1199,12 +1199,12 @@ export declare const expr: {
         default?: ExprInput<T>;
     }): ExprUnit<T | undefined>;
     /**
-     * LEAD() - 다음 행의 값 참조
+     * LEAD() - 다음 행의 value 참조
      *
-     * @param column - 참조할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @param options - offset (기본 1), default (다음 행이 없을 때 기본값)
-     * @returns 다음 행의 값 (또는 기본값/NULL)
+     * @param column - column to reference
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @param options - offset (Basic 1), default (다음 행이 없을 때 Default value)
+     * @returns 다음 행의 value (또는 Default value/NULL)
      *
      * @example
      * ```typescript
@@ -1223,11 +1223,11 @@ export declare const expr: {
         default?: ExprInput<T>;
     }): ExprUnit<T | undefined>;
     /**
-     * FIRST_VALUE() - 파티션/프레임의 첫 번째 값
+     * FIRST_VALUE() - 파티션/프레임의 첫 번째 value
      *
-     * @param column - 참조할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 첫 번째 값
+     * @param column - column to reference
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns 첫 번째 value
      *
      * @example
      * ```typescript
@@ -1242,11 +1242,11 @@ export declare const expr: {
      */
     firstValue<T extends ColumnPrimitive>(column: ExprUnit<T>, spec: WinSpecInput): ExprUnit<T | undefined>;
     /**
-     * LAST_VALUE() - 파티션/프레임의 마지막 값
+     * LAST_VALUE() - 파티션/프레임의 마지막 value
      *
-     * @param column - 참조할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 마지막 값
+     * @param column - column to reference
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns 마지막 value
      *
      * @example
      * ```typescript
@@ -1261,11 +1261,11 @@ export declare const expr: {
      */
     lastValue<T extends ColumnPrimitive>(column: ExprUnit<T>, spec: WinSpecInput): ExprUnit<T | undefined>;
     /**
-     * SUM() OVER - 윈도우 합계
+     * SUM() OVER - Window 합계
      *
-     * @param column - 합계를 구할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 윈도우 내 합계
+     * @param column - 합계를 구할 column
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns Window 내 합계
      *
      * @example
      * ```typescript
@@ -1281,15 +1281,15 @@ export declare const expr: {
      */
     sumOver(column: ExprUnit<number | undefined>, spec: WinSpecInput): ExprUnit<number | undefined>;
     /**
-     * AVG() OVER - 윈도우 평균
+     * AVG() OVER - Window 평균
      *
-     * @param column - 평균을 구할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 윈도우 내 평균
+     * @param column - 평균을 구할 column
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns Window 내 평균
      *
      * @example
      * ```typescript
-     * // 이동 평균
+     * // move 평균
      * db.stock().select((s) => ({
      *   ...s,
      *   movingAvg: expr.avgOver(s.price, {
@@ -1301,11 +1301,11 @@ export declare const expr: {
      */
     avgOver(column: ExprUnit<number | undefined>, spec: WinSpecInput): ExprUnit<number | undefined>;
     /**
-     * COUNT() OVER - 윈도우 카운트
+     * COUNT() OVER - Window 카운트
      *
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @param column - 카운트할 컬럼 (생략 시 전체 행 수)
-     * @returns 윈도우 내 행 수
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @param column - 카운트할 column (생략 시 전체 row 수)
+     * @returns Window 내 row 수
      *
      * @example
      * ```typescript
@@ -1319,11 +1319,11 @@ export declare const expr: {
      */
     countOver(spec: WinSpecInput, column?: ExprUnit<ColumnPrimitive>): ExprUnit<number>;
     /**
-     * MIN() OVER - 윈도우 최소값
+     * MIN() OVER - Window 최소값
      *
-     * @param column - 최소값을 구할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 윈도우 내 최소값
+     * @param column - 최소값을 구할 column
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns Window 내 최소값
      *
      * @example
      * ```typescript
@@ -1337,11 +1337,11 @@ export declare const expr: {
      */
     minOver<T extends ColumnPrimitive>(column: ExprUnit<T>, spec: WinSpecInput): ExprUnit<T | undefined>;
     /**
-     * MAX() OVER - 윈도우 최대값
+     * MAX() OVER - Window 최대값
      *
-     * @param column - 최대값을 구할 컬럼
-     * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-     * @returns 윈도우 내 최대값
+     * @param column - 최대값을 구할 column
+     * @param spec - Window spec (partitionBy, orderBy)
+     * @returns Window 내 최대값
      *
      * @example
      * ```typescript
@@ -1355,9 +1355,9 @@ export declare const expr: {
      */
     maxOver<T extends ColumnPrimitive>(column: ExprUnit<T>, spec: WinSpecInput): ExprUnit<T | undefined>;
     /**
-     * ExprInput을 Expr로 변환 (내부용)
+     * ExprInput을 Expr로 Transform (내부용)
      *
-     * @param value - 변환할 값
+     * @param value - Transform할 value
      * @returns Expr JSON AST
      */
     toExpr(value: ExprInput<ColumnPrimitive>): Expr;