FM / query-builder

/opt/canhelp/node_modules/kysely/dist/cjs/query-builder/

/opt/canhelp/node_modules/kysely/dist/cjs/query-builder

Name	Size	Mode	Actions
aggregate-function-builder.d.ts	13602	0644	edit dl rm
aggregate-function-builder.js	8276	0644	edit dl rm
case-builder.d.ts	6689	0644	edit dl rm
case-builder.js	3353	0644	edit dl rm
cte-builder.d.ts	802	0644	edit dl rm
cte-builder.js	1160	0644	edit dl rm
delete-query-builder.d.ts	47443	0644	edit dl rm
delete-query-builder.js	16599	0644	edit dl rm
delete-result.d.ts	116	0644	edit dl rm
delete-result.js	274	0644	edit dl rm
function-module.d.ts	23521	0644	edit dl rm
function-module.js	2856	0644	edit dl rm
having-interface.d.ts	953	0644	edit dl rm
having-interface.js	77	0644	edit dl rm
insert-query-builder.d.ts	40215	0644	edit dl rm
insert-query-builder.js	36813	0644	edit dl rm
insert-result.d.ts	1735	0644	edit dl rm
insert-result.js	1874	0644	edit dl rm
join-builder.d.ts	1773	0644	edit dl rm
join-builder.js	1806	0644	edit dl rm
json-path-builder.d.ts	9545	0644	edit dl rm
json-path-builder.js	6418	0644	edit dl rm
merge-query-builder.d.ts	37025	0644	edit dl rm
merge-query-builder.js	21626	0644	edit dl rm
merge-result.d.ts	139	0644	edit dl rm
merge-result.js	270	0644	edit dl rm
no-result-error.d.ts	478	0644	edit dl rm
no-result-error.js	534	0644	edit dl rm
on-conflict-builder.d.ts	25573	0644	edit dl rm
on-conflict-builder.js	9028	0644	edit dl rm
order-by-interface.d.ts	4883	0644	edit dl rm
order-by-interface.js	77	0644	edit dl rm
order-by-item-builder.d.ts	1372	0644	edit dl rm
order-by-item-builder.js	2457	0644	edit dl rm
output-interface.d.ts	5477	0644	edit dl rm
output-interface.js	77	0644	edit dl rm
over-builder.d.ts	3755	0644	edit dl rm
over-builder.js	1495	0644	edit dl rm
returning-interface.d.ts	3496	0644	edit dl rm
returning-interface.js	77	0644	edit dl rm
select-query-builder-expression.d.ts	962	0644	edit dl rm
select-query-builder-expression.js	77	0644	edit dl rm
select-query-builder.d.ts	78467	0644	edit dl rm
select-query-builder.js	15038	0644	edit dl rm
update-query-builder.d.ts	50254	0644	edit dl rm
update-query-builder.js	17236	0644	edit dl rm
update-result.d.ts	497	0644	edit dl rm
update-result.js	663	0644	edit dl rm
where-interface.d.ts	10814	0644	edit dl rm
where-interface.js	77	0644	edit dl rm

Edit: /opt/canhelp/node_modules/kysely/dist/cjs/query-builder/case-builder.d.ts (6689B)

import type { Expression } from '../expression/expression.js';
import { ExpressionWrapper } from '../expression/expression-wrapper.js';
import type { ReferenceExpression } from '../parser/reference-parser.js';
import { CaseNode } from '../operation-node/case-node.js';
import { type ComparisonOperatorExpression, type OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
import { type ExtractTypeFromValueExpression } from '../parser/value-parser.js';
import type { KyselyTypeError } from '../util/type-error.js';
export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never> implements Whenable<DB, TB, W, O> {
    #private;
    constructor(props: CaseBuilderProps);
    /**
     * Adds a `when` clause to the case statement.
     *
     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
     */
    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
}
interface CaseBuilderProps {
    readonly node: CaseNode;
}
export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
    #private;
    constructor(props: CaseBuilderProps);
    /**
     * Adds a `then` clause to the `case` statement.
     *
     * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
     * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
     *
     * **Note:** Numbers, booleans, and `null` values are inlined directly into the
     * SQL query string (e.g. `then 1`, `then true`, `then null`) instead of being
     * added as parameterized values (e.g. `then $1`). This allows the database
     * engine to correctly infer the data type of the `case` expression result.
     * Without this behavior, all results would be returned as strings.
     *
     * String values are always parameterized as usual.
     */
    then<E extends Expression<unknown>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
    then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
}
export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<DB, TB, O | null> {
    #private;
    constructor(props: CaseBuilderProps);
    /**
     * Adds a `when` clause to the case statement.
     *
     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
     */
    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
    /**
     * Adds an `else` clause to the `case` statement.
     *
     * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
     *
     * **Note:** Numbers, booleans, and `null` values are inlined directly into the
     * SQL query string (e.g. `else 0`, `else false`, `else null`) instead of being
     * added as parameterized values (e.g. `else $1`). This allows the database
     * engine to correctly infer the data type of the `case` expression result.
     * Without this behavior, all results would be returned as strings.
     *
     * String values are always parameterized as usual.
     */
    else<E extends Expression<unknown>>(expression: E): CaseEndBuilder<DB, TB, O | ExtractTypeFromValueExpression<E>>;
    else<V>(value: V): CaseEndBuilder<DB, TB, O | V>;
    /**
     * Adds an `end` keyword to the case operator.
     *
     * `case` operators can only be used as part of a query.
     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
     */
    end(): ExpressionWrapper<DB, TB, O | null>;
    /**
     * Adds `end case` keywords to the case statement.
     *
     * `case` statements can only be used for flow control in stored programs.
     * For a `case` operator used as part of a query, use {@link end} instead.
     */
    endCase(): ExpressionWrapper<DB, TB, O | null>;
}
export declare class CaseEndBuilder<DB, TB extends keyof DB, O> implements Endable<DB, TB, O> {
    #private;
    constructor(props: CaseBuilderProps);
    /**
     * Adds an `end` keyword to the case operator.
     *
     * `case` operators can only be used as part of a query.
     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
     */
    end(): ExpressionWrapper<DB, TB, O>;
    /**
     * Adds `end case` keywords to the case statement.
     *
     * `case` statements can only be used for flow control in stored programs.
     * For a `case` operator used as part of a query, use {@link end} instead.
     */
    endCase(): ExpressionWrapper<DB, TB, O>;
}
interface Whenable<DB, TB extends keyof DB, W, O> {
    /**
     * Adds a `when` clause to the case statement.
     *
     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
     */
    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
}
interface Endable<DB, TB extends keyof DB, O> {
    /**
     * Adds an `end` keyword to the case operator.
     *
     * `case` operators can only be used as part of a query.
     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
     */
    end(): ExpressionWrapper<DB, TB, O>;
    /**
     * Adds `end case` keywords to the case statement.
     *
     * `case` statements can only be used for flow control in stored programs.
     * For a `case` operator used as part of a query, use {@link end} instead.
     */
    endCase(): ExpressionWrapper<DB, TB, O>;
}
export {};

cmd: