kysely 0.28.17 → 0.29.0

package/dist/operation-node/references-node.js

@@ -0,0 +1,43 @@
+/// <reference types="./references-node.d.ts" />
+import { freeze, isString } from '../util/object-utils.js';
+const ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY = freeze({
+    cascade: true,
+    'no action': true,
+    restrict: true,
+    'set default': true,
+    'set null': true,
+});
+/**
+ * @deprecated will be removed in version 0.30.x
+ */
+export const ON_MODIFY_FOREIGN_ACTIONS = Object.keys(ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY);
+/**
+ * @internal
+ */
+export const ReferencesNode = freeze({
+    is(node) {
+        return node.kind === 'ReferencesNode';
+    },
+    create(table, columns) {
+        return freeze({
+            kind: 'ReferencesNode',
+            table,
+            columns: freeze([...columns]),
+        });
+    },
+    cloneWithOnDelete(references, onDelete) {
+        return freeze({
+            ...references,
+            onDelete,
+        });
+    },
+    cloneWithOnUpdate(references, onUpdate) {
+        return freeze({
+            ...references,
+            onUpdate,
+        });
+    },
+});
+export function isOnModifyForeignAction(thing) {
+    return isString(thing) && ON_MODIFY_FOREIGN_ACTIONS_DICTIONARY[thing];
+}

package/dist/operation-node/rename-value-node.d.ts

@@ -0,0 +1,14 @@
+import type { OperationNode } from './operation-node.js';
+import type { ValueNode } from './value-node.js';
+export type RenameValueNodeProps = Omit<RenameValueNode, 'kind'>;
+export interface RenameValueNode extends OperationNode {
+    readonly kind: 'RenameValueNode';
+    readonly oldValue: ValueNode;
+    readonly newValue: ValueNode;
+}
+type RenameValueNodeFactory = Readonly<{
+    is(node: OperationNode): node is RenameValueNode;
+    create(existingEnumValue: ValueNode, newEnumValue: ValueNode): Readonly<RenameValueNode>;
+}>;
+export declare const RenameValueNode: RenameValueNodeFactory;
+export {};

package/dist/operation-node/rename-value-node.js

@@ -0,0 +1,14 @@
+/// <reference types="./rename-value-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+export const RenameValueNode = freeze({
+    is(node) {
+        return node.kind === 'RenameValueNode';
+    },
+    create(oldValue, newValue) {
+        return freeze({
+            kind: 'RenameValueNode',
+            oldValue,
+            newValue,
+        });
+    },
+});

package/dist/operation-node/root-operation-node.d.ts

@@ -0,0 +1,17 @@
+import type { AlterTableNode } from './alter-table-node.js';
+import type { AlterTypeNode } from './alter-type-node.js';
+import type { CreateIndexNode } from './create-index-node.js';
+import type { CreateSchemaNode } from './create-schema-node.js';
+import type { CreateTableNode } from './create-table-node.js';
+import type { CreateTypeNode } from './create-type-node.js';
+import type { CreateViewNode } from './create-view-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { DropSchemaNode } from './drop-schema-node.js';
+import type { DropTableNode } from './drop-table-node.js';
+import type { DropTypeNode } from './drop-type-node.js';
+import type { DropViewNode } from './drop-view-node.js';
+import type { QueryNode } from './query-node.js';
+import type { RawNode } from './raw-node.js';
+import type { RefreshMaterializedViewNode } from './refresh-materialized-view-node.js';
+export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | RefreshMaterializedViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode | AlterTypeNode;
+export declare function isRootOperationNode(thing: unknown): thing is RootOperationNode;

package/dist/operation-node/root-operation-node.js

@@ -0,0 +1,27 @@
+/// <reference types="./root-operation-node.d.ts" />
+import { isOperationNode } from './operation-node.js';
+const ROOT_OPERATION_NODE_KINDS = {
+    AlterTableNode: true,
+    AlterTypeNode: true,
+    CreateIndexNode: true,
+    CreateSchemaNode: true,
+    CreateTableNode: true,
+    CreateTypeNode: true,
+    CreateViewNode: true,
+    DeleteQueryNode: true,
+    DropIndexNode: true,
+    DropSchemaNode: true,
+    DropTableNode: true,
+    DropTypeNode: true,
+    RefreshMaterializedViewNode: true,
+    DropViewNode: true,
+    InsertQueryNode: true,
+    RawNode: true,
+    SelectQueryNode: true,
+    UpdateQueryNode: true,
+    MergeQueryNode: true,
+};
+export function isRootOperationNode(thing) {
+    return (isOperationNode(thing) &&
+        ROOT_OPERATION_NODE_KINDS[thing.kind] === true);
+}

package/dist/operation-node/unique-constraint-node.d.ts

@@ -0,0 +1,30 @@
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface UniqueConstraintNode extends OperationNode {
+    readonly kind: 'UniqueConstraintNode';
+    readonly columns: ReadonlyArray<OperationNode>;
+    readonly name?: IdentifierNode;
+    readonly nullsNotDistinct?: boolean;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
+/**
+ * TODO: remove this interface once support for `string[]` is removed.
+ *
+ * @internal
+ */
+type UniqueConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is UniqueConstraintNode;
+    create(columns: OperationNode[], constraintName?: string, nullsNotDistinct?: boolean): UniqueConstraintNode;
+    /**
+     * @deprecated pass `ColumnNode[]` instead of strings.
+     */
+    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): UniqueConstraintNode;
+    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): UniqueConstraintNode;
+}>;
+/**
+ * @internal
+ */
+export declare const UniqueConstraintNode: UniqueConstraintNodeFactory;
+export {};

package/dist/operation-node/unique-constraint-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./unique-constraint-node.d.ts" />
+import { logOnce } from '../util/log-once.js';
+import { freeze, isString } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const UniqueConstraintNode = freeze({
+    is(node) {
+        return node.kind === 'UniqueConstraintNode';
+    },
+    create(columns, constraintName, nullsNotDistinct) {
+        // TODO: remove this block when support for `string[]` is removed.
+        if (isString(columns.at(0))) {
+            logOnce('`UniqueConstraintNode.create(columns: string[], ...)` is deprecated - pass `ColumnNode[]` instead.');
+            columns = columns.map(ColumnNode.create);
+        }
+        return freeze({
+            kind: 'UniqueConstraintNode',
+            columns: freeze(columns),
+            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+            nullsNotDistinct,
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({ ...node, ...props });
+    },
+});

package/dist/parser/binary-operation-parser.js

@@ -0,0 +1,68 @@
+/// <reference types="./binary-operation-parser.d.ts" />
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { isBoolean, isNull, isUndefined } from '../util/object-utils.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { OperatorNode, isBinaryOperator, } from '../operation-node/operator-node.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+import { parseValueExpression, parseValueExpressionOrList, } from './value-parser.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { AndNode } from '../operation-node/and-node.js';
+import { ParensNode } from '../operation-node/parens-node.js';
+import { OrNode } from '../operation-node/or-node.js';
+export function parseValueBinaryOperationOrExpression(args) {
+    if (args.length === 3) {
+        return parseValueBinaryOperation(args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        return parseValueExpression(args[0]);
+    }
+    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
+}
+export function parseValueBinaryOperation(left, operator, right) {
+    if (isIsOperator(operator) && needsIsOperator(right)) {
+        return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), ValueNode.createImmediate(right));
+    }
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), parseValueExpressionOrList(right));
+}
+export function parseReferentialBinaryOperation(left, operator, right) {
+    return BinaryOperationNode.create(parseReferenceExpression(left), parseBinaryOperator(operator), parseReferenceExpression(right));
+}
+export function parseFilterObject(obj, combinator) {
+    return parseFilterList(Object.entries(obj)
+        .filter(([, v]) => !isUndefined(v))
+        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
+}
+export function parseFilterList(list, combinator, withParens = true) {
+    const combine = combinator === 'and' ? AndNode.create : OrNode.create;
+    if (list.length === 0) {
+        return BinaryOperationNode.create(ValueNode.createImmediate(1), OperatorNode.create('='), ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
+    }
+    let node = toOperationNode(list[0]);
+    for (let i = 1; i < list.length; ++i) {
+        node = combine(node, toOperationNode(list[i]));
+    }
+    if (list.length > 1 && withParens) {
+        return ParensNode.create(node);
+    }
+    return node;
+}
+function isIsOperator(operator) {
+    return operator === 'is' || operator === 'is not';
+}
+function needsIsOperator(value) {
+    return isNull(value) || isBoolean(value);
+}
+function parseBinaryOperator(operator) {
+    if (isBinaryOperator(operator)) {
+        return OperatorNode.create(operator);
+    }
+    if (isOperationNodeSource(operator)) {
+        return operator.toOperationNode();
+    }
+    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
+}
+function toOperationNode(nodeOrSource) {
+    return isOperationNodeSource(nodeOrSource)
+        ? nodeOrSource.toOperationNode()
+        : nodeOrSource;
+}

package/dist/parser/identifier-parser.d.ts

@@ -0,0 +1,3 @@
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export declare function parseSchemableIdentifier(id: string): SchemableIdentifierNode;
+export declare function parseSchemableIdentifierArray(id: string | string[]): SchemableIdentifierNode[];

package/dist/parser/identifier-parser.js

@@ -0,0 +1,26 @@
+/// <reference types="./identifier-parser.d.ts" />
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export function parseSchemableIdentifier(id) {
+    const SCHEMA_SEPARATOR = '.';
+    if (id.includes(SCHEMA_SEPARATOR)) {
+        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
+        if (parts.length === 2) {
+            return SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid schemable identifier ${id}`);
+        }
+    }
+    else {
+        return SchemableIdentifierNode.create(id);
+    }
+}
+export function parseSchemableIdentifierArray(id) {
+    if (!Array.isArray(id)) {
+        id = [id];
+    }
+    return id.map(parseSchemableIdentifier);
+}
+function trim(str) {
+    return str.trim();
+}

package/dist/parser/on-modify-action-parser.d.ts

@@ -0,0 +1,2 @@
+import { type OnModifyForeignAction } from '../operation-node/references-node.js';
+export declare function parseOnModifyForeignAction(action: string): OnModifyForeignAction;

package/dist/parser/on-modify-action-parser.js

@@ -0,0 +1,8 @@
+/// <reference types="./on-modify-action-parser.d.ts" />
+import { isOnModifyForeignAction, } from '../operation-node/references-node.js';
+export function parseOnModifyForeignAction(action) {
+    if (isOnModifyForeignAction(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnModifyForeignAction ${action}`);
+}

package/dist/parser/reference-parser.js

@@ -0,0 +1,93 @@
+/// <reference types="./reference-parser.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
+import { OperatorNode, isJSONOperator, } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
+export function parseSimpleReferenceExpression(exp) {
+    if (isString(exp)) {
+        return parseStringReference(exp);
+    }
+    return exp.toOperationNode();
+}
+export function parseReferenceExpressionOrList(arg) {
+    if (isReadonlyArray(arg)) {
+        return arg.map((it) => parseReferenceExpression(it));
+    }
+    else {
+        return [parseReferenceExpression(arg)];
+    }
+}
+export function parseReferenceExpression(exp) {
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
+    }
+    return parseSimpleReferenceExpression(exp);
+}
+export function parseJSONReference(ref, op) {
+    if (isJSONOperator(op)) {
+        return JSONReferenceNode.create(parseStringReference(ref), JSONOperatorChainNode.create(OperatorNode.create(op)));
+    }
+    if (op === '->$' || op === '->>$') {
+        return JSONReferenceNode.create(parseStringReference(ref), JSONPathNode.create(OperatorNode.create(op.slice(0, -1))));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
+export function parseStringReference(ref) {
+    const COLUMN_SEPARATOR = '.';
+    if (!ref.includes(COLUMN_SEPARATOR)) {
+        return ReferenceNode.create(ColumnNode.create(ref));
+    }
+    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
+    if (parts.length === 3) {
+        return parseStringReferenceWithTableAndSchema(parts);
+    }
+    if (parts.length === 2) {
+        return parseStringReferenceWithTable(parts);
+    }
+    throw new Error(`invalid column reference ${ref}`);
+}
+export function parseAliasedStringReference(ref) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (ref.includes(ALIAS_SEPARATOR)) {
+        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
+    }
+    else {
+        return parseStringReference(ref);
+    }
+}
+export function parseColumnName(column) {
+    return ColumnNode.create(column);
+}
+export function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!isOrderByDirection(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return parseOrderBy([columnName, order])[0];
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
+function parseStringReferenceWithTableAndSchema(parts) {
+    const [schema, table, column] = parts;
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
+}
+function parseStringReferenceWithTable(parts) {
+    const [table, column] = parts;
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
+}
+function trim(str) {
+    return str.trim();
+}

package/dist/parser/unary-operation-parser.js

@@ -0,0 +1,16 @@
+/// <reference types="./unary-operation-parser.d.ts" />
+import { isUnaryOperator, OperatorNode, } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
+}
+export function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
+}
+export function parseUnaryOperation(operator, operand) {
+    if (isUnaryOperator(operator)) {
+        return UnaryOperationNode.create(OperatorNode.create(operator), parseReferenceExpression(operand));
+    }
+    throw new Error(`invalid unary operator ${JSON.stringify(operator)}`);
+}

package/dist/parser/with-parser.d.ts

@@ -0,0 +1,46 @@
+import type { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import type { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
+import type { QueryCreator } from '../query-creator.js';
+import { type CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+import type { Compilable } from '../util/compilable.js';
+import type { Expression } from '../expression/expression.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+export type CommonTableExpression<DB, CN> = CommonTableExpressionOutput<DB, CN> | CommonTableExpressionFactory<DB, CN>;
+export type CommonTableExpressionFactory<DB, CN> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
+export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
+}>) => CommonTableExpressionOutput<DB, CN>;
+export type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpression<CTE>;
+}>;
+export type CommonTableExpressionOutput<DB, CN> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
+/**
+ * Given a common CommonTableExpression CTE extracts the row type from it.
+ *
+ * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
+ * would result in `Pick<Person, 'id' | 'first_name'>`.
+ */
+export type ExtractRowFromCommonTableExpression<CTE> = CTE extends Expression<infer O> | Compilable<infer O> ? O : CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer O> | Compilable<infer O> ? O : never : never;
+/**
+ * Extracts 'person' from a string like 'person(id, first_name)'.
+ */
+export type ExtractTableFromCommonTableExpressionName<CN> = CN extends `${infer TB}(${string})` ? TB : CN;
+/**
+ * Parses a string like 'person(id, first_name)' into a type:
+ *
+ * {
+ *   id: any,
+ *   first_name: any
+ * }
+ */
+export type ExtractRowFromCommonTableExpressionName<CN> = CN extends `${string}(${infer CL})` ? {
+    [C in ExtractColumnNamesFromColumnList<CL>]: any;
+} : ShallowRecord<string, any>;
+/**
+ * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
+ */
+type ExtractColumnNamesFromColumnList<R> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
+export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
+export {};

package/dist/parser/with-parser.js

@@ -0,0 +1,34 @@
+/// <reference types="./with-parser.d.ts" />
+import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
+import { createQueryCreator } from './parse-utils.js';
+import { isFunction } from '../util/object-utils.js';
+import { CTEBuilder, } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+export function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = isOperationNodeSource(expression)
+        ? expression.toOperationNode()
+        : expression(createQueryCreator()).toOperationNode();
+    if (isFunction(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new CTEBuilder({
+            node: CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
+}
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return CommonTableExpressionNameNode.create(name);
+    }
+}

package/dist/plugin/camel-case/camel-case-plugin.d.ts

@@ -0,0 +1,170 @@
+import type { QueryResult } from '../../driver/database-connection.js';
+import type { RootOperationNode } from '../../operation-node/root-operation-node.js';
+import type { UnknownRow } from '../../util/type-utils.js';
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+export interface CamelCasePluginOptions {
+    /**
+     * If true, camelCase is transformed into upper case SNAKE_CASE.
+     * For example `fooBar => FOO_BAR` and `FOO_BAR => fooBar`
+     *
+     * Defaults to false.
+     */
+    upperCase?: boolean;
+    /**
+     * If true, an underscore is added before each digit when converting
+     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
+     * `foo_12_bar => foo12Bar`
+     *
+     * Defaults to false.
+     */
+    underscoreBeforeDigits?: boolean;
+    /**
+     * If true, an underscore is added between consecutive upper case
+     * letters when converting from camelCase to snake_case. For example
+     * `fooBAR => foo_b_a_r` and `foo_b_a_r => fooBAR`.
+     *
+     * Defaults to false.
+     */
+    underscoreBetweenUppercaseLetters?: boolean;
+    /**
+     * If true, nested object's keys will not be converted to camel case.
+     *
+     * Defaults to false.
+     */
+    maintainNestedObjectKeys?: boolean;
+}
+/**
+ * A plugin that converts snake_case identifiers in the database into
+ * camelCase in the JavaScript side.
+ *
+ * For example let's assume we have a table called `person_table`
+ * with columns `first_name` and `last_name` in the database. When
+ * using `CamelCasePlugin` we would setup Kysely like this:
+ *
+ * ```ts
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
+ *
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
+ * }
+ *
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [new CamelCasePlugin()],
+ * })
+ *
+ * const person = await db.selectFrom('userMetadata')
+ *   .where('firstName', '=', 'Arnold')
+ *   .select(['firstName', 'lastName'])
+ *   .executeTakeFirst()
+ *
+ * if (person) {
+ *   console.log(person.firstName)
+ * }
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
+ * As you can see from the example, __everything__ needs to be defined
+ * in camelCase in the TypeScript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
+ *
+ * There are various options you can give to the plugin to modify
+ * the way identifiers are converted. See {@link CamelCasePluginOptions}.
+ * If those options are not enough, you can override this plugin's
+ * `snakeCase` and `camelCase` methods to make the conversion exactly
+ * the way you like:
+ *
+ * ```ts
+ * class MyCamelCasePlugin extends CamelCasePlugin {
+ *   protected override snakeCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ *
+ *   protected override camelCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ * }
+ * ```
+ */
+export declare class CamelCasePlugin implements KyselyPlugin {
+    #private;
+    readonly opt: CamelCasePluginOptions;
+    constructor(opt?: CamelCasePluginOptions);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
+     *
+     * const plugin = {
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
+     *     return args.node
+     *   },
+     *
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
+     *     return args.result
+     *   }
+     * } satisfies KyselyPlugin
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+    protected mapRow(row: UnknownRow): UnknownRow;
+    protected snakeCase(str: string): string;
+    protected camelCase(str: string): string;
+}