kysely 0.27.4 → 0.27.5

package/dist/esm/expression/expression-wrapper.d.ts

@@ -17,11 +17,19 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * All expressions need to have this getter for complicated type-related reasons.
      * Simply add this getter for your expression and always return `undefined` from it:
      *
+     * ### Examples
+     *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
      *   get expressionType(): T | undefined {
      *     return undefined
      *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
      * }
      * ```
      *
@@ -33,6 +41,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
     /**
      * Returns an aliased version of the expression.
      *
+     * ### Examples
+     *
      * In addition to slapping `as "the_alias"` to the end of the SQL,
      * this method also provides strict typing:
      *
@@ -50,7 +60,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select "first_name" = $1 as "is_jennifer"
      * from "person"
      * ```
@@ -59,6 +69,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
     /**
      * Returns an aliased version of the expression.
      *
+     * ### Examples
+     *
      * In addition to slapping `as "the_alias"` at the end of the expression,
      * this method also provides strict typing:
      *
@@ -67,7 +79,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *   .selectFrom('person')
      *   .select((eb) =>
      *     // `eb.fn<string>` returns an AliasableExpression<string>
-     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -77,7 +89,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select
      *   concat("first_name", $1, "last_name") as "full_name"
      * from
@@ -88,6 +100,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * provide the alias as the only type argument:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
      *
      * // The alias is `t(a, b)` which specifies the column names
@@ -102,11 +116,12 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *   .expression(
      *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * insert into "person" ("first_name", "last_name")
      * from (values (1, 'foo')) as t(a, b)
      * select "t"."a", "t"."b"
@@ -121,17 +136,18 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * ### Examples
      *
      * ```ts
-     * db.selectFrom('person')
+     * const result = await db.selectFrom('person')
      *   .selectAll()
      *   .where(eb => eb('first_name', '=', 'Jennifer')
      *     .or('first_name', '=', 'Arnold')
      *     .or('first_name', '=', 'Sylvester')
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select *
      * from "person"
      * where (
@@ -145,7 +161,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * this method:
      *
      * ```ts
-     * db.selectFrom('person')
+     * const result = await db.selectFrom('person')
      *   .selectAll()
      *   .where(eb => eb('first_name', '=', 'Jennifer')
      *     .or(eb('first_name', '=', 'Sylvester').and('last_name', '=', 'Stallone'))
@@ -153,13 +169,14 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *       eb.selectFrom('pet')
      *         .select('id')
      *         .whereRef('pet.owner_id', '=', 'person.id')
-     *     )
+     *     ))
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select *
      * from "person"
      * where (
@@ -183,17 +200,18 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * ### Examples
      *
      * ```ts
-     * db.selectFrom('person')
+     * const result = await db.selectFrom('person')
      *   .selectAll()
      *   .where(eb => eb('first_name', '=', 'Jennifer')
      *     .and('last_name', '=', 'Aniston')
      *     .and('age', '>', 40)
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select *
      * from "person"
      * where (
@@ -207,7 +225,7 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * this method:
      *
      * ```ts
-     * db.selectFrom('person')
+     * const result = await db.selectFrom('person')
      *   .selectAll()
      *   .where(eb => eb('first_name', '=', 'Jennifer')
      *     .and(eb('first_name', '=', 'Sylvester').or('last_name', '=', 'Stallone'))
@@ -215,13 +233,14 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      *       eb.selectFrom('pet')
      *         .select('id')
      *         .whereRef('pet.owner_id', '=', 'person.id')
-     *     )
+     *     ))
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select *
      * from "person"
      * where (
@@ -257,11 +276,19 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
+     * ### Examples
+     *
      * If you are creating a custom expression, it's often easiest to use the {@link sql}
      * template tag to build the node:
      *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
      *   toOperationNode(): OperationNode {
      *     return sql`some sql here`.toOperationNode()
      *   }
@@ -296,11 +323,19 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * All expressions need to have this getter for complicated type-related reasons.
      * Simply add this getter for your expression and always return `undefined` from it:
      *
+     * ### Examples
+     *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
      *   get expressionType(): T | undefined {
      *     return undefined
      *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
      * }
      * ```
      *
@@ -331,7 +366,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select "first_name" = $1 or "first_name" = $2 as "is_jennifer_or_sylvester"
      * from "person"
      * ```
@@ -340,6 +375,8 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
     /**
      * Returns an aliased version of the expression.
      *
+     * ### Examples
+     *
      * In addition to slapping `as "the_alias"` at the end of the expression,
      * this method also provides strict typing:
      *
@@ -348,7 +385,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *   .selectFrom('person')
      *   .select((eb) =>
      *     // `eb.fn<string>` returns an AliasableExpression<string>
-     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -358,7 +395,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select
      *   concat("first_name", $1, "last_name") as "full_name"
      * from
@@ -369,6 +406,8 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * provide the alias as the only type argument:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
      *
      * // The alias is `t(a, b)` which specifies the column names
@@ -383,11 +422,12 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *   .expression(
      *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * insert into "person" ("first_name", "last_name")
      * from (values (1, 'foo')) as t(a, b)
      * select "t"."a", "t"."b"
@@ -411,11 +451,19 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
+     * ### Examples
+     *
      * If you are creating a custom expression, it's often easiest to use the {@link sql}
      * template tag to build the node:
      *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
      *   toOperationNode(): OperationNode {
      *     return sql`some sql here`.toOperationNode()
      *   }
@@ -432,11 +480,19 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * All expressions need to have this getter for complicated type-related reasons.
      * Simply add this getter for your expression and always return `undefined` from it:
      *
+     * ### Examples
+     *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
      *   get expressionType(): T | undefined {
      *     return undefined
      *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
      * }
      * ```
      *
@@ -462,12 +518,12 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *   .executeTakeFirstOrThrow()
      *
      * // `is_jennifer_aniston: SqlBool` field exists in the result type.
-     * console.log(result.is_jennifer_or_sylvester)
+     * console.log(result.is_jennifer_aniston)
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select "first_name" = $1 and "first_name" = $2 as "is_jennifer_aniston"
      * from "person"
      * ```
@@ -476,6 +532,8 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
     /**
      * Returns an aliased version of the expression.
      *
+     * ### Examples
+     *
      * In addition to slapping `as "the_alias"` at the end of the expression,
      * this method also provides strict typing:
      *
@@ -484,7 +542,7 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *   .selectFrom('person')
      *   .select((eb) =>
      *     // `eb.fn<string>` returns an AliasableExpression<string>
-     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -494,7 +552,7 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select
      *   concat("first_name", $1, "last_name") as "full_name"
      * from
@@ -505,6 +563,8 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * provide the alias as the only type argument:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
      *
      * // The alias is `t(a, b)` which specifies the column names
@@ -519,11 +579,12 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *   .expression(
      *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * insert into "person" ("first_name", "last_name")
      * from (values (1, 'foo')) as t(a, b)
      * select "t"."a", "t"."b"
@@ -547,11 +608,19 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
+     * ### Examples
+     *
      * If you are creating a custom expression, it's often easiest to use the {@link sql}
      * template tag to build the node:
      *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
      *   toOperationNode(): OperationNode {
      *     return sql`some sql here`.toOperationNode()
      *   }

package/dist/esm/expression/expression.d.ts

@@ -7,7 +7,11 @@ import { OperationNode } from '../operation-node/operation-node.js';
  * Most Kysely methods accept instances of `Expression` and most classes like `SelectQueryBuilder`
  * and the return value of the {@link sql} template tag implement it.
  *
+ * ### Examples
+ *
  * ```ts
+ * import { type Expression, sql } from 'kysely'
+ *
  * const exp1: Expression<string> = sql<string>`CONCAT('hello', ' ', 'world')`
  * const exp2: Expression<{ first_name: string }> = db.selectFrom('person').select('first_name')
  * ```
@@ -19,11 +23,19 @@ export interface Expression<T> extends OperationNodeSource {
      * All expressions need to have this getter for complicated type-related reasons.
      * Simply add this getter for your expression and always return `undefined` from it:
      *
+     * ### Examples
+     *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
      *   get expressionType(): T | undefined {
      *     return undefined
      *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
      * }
      * ```
      *
@@ -35,11 +47,19 @@ export interface Expression<T> extends OperationNodeSource {
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
+     * ### Examples
+     *
      * If you are creating a custom expression, it's often easiest to use the {@link sql}
      * template tag to build the node:
      *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
      *   toOperationNode(): OperationNode {
      *     return sql`some sql here`.toOperationNode()
      *   }
@@ -55,6 +75,8 @@ export interface AliasableExpression<T> extends Expression<T> {
     /**
      * Returns an aliased version of the expression.
      *
+     * ### Examples
+     *
      * In addition to slapping `as "the_alias"` at the end of the expression,
      * this method also provides strict typing:
      *
@@ -63,7 +85,7 @@ export interface AliasableExpression<T> extends Expression<T> {
      *   .selectFrom('person')
      *   .select((eb) =>
      *     // `eb.fn<string>` returns an AliasableExpression<string>
-     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -73,7 +95,7 @@ export interface AliasableExpression<T> extends Expression<T> {
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * select
      *   concat("first_name", $1, "last_name") as "full_name"
      * from
@@ -84,6 +106,8 @@ export interface AliasableExpression<T> extends Expression<T> {
      * provide the alias as the only type argument:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
      *
      * // The alias is `t(a, b)` which specifies the column names
@@ -98,11 +122,12 @@ export interface AliasableExpression<T> extends Expression<T> {
      *   .expression(
      *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
-     * ```ts
+     * ```sql
      * insert into "person" ("first_name", "last_name")
      * from (values (1, 'foo')) as t(a, b)
      * select "t"."a", "t"."b"
@@ -119,9 +144,16 @@ export interface AliasableExpression<T> extends Expression<T> {
  * needs to implement an `AliasedExpression<T, A>`. `A` becomes the name of the selected expression
  * in the result and `T` becomes its type.
  *
- * @example
+ * ### Examples
  *
  * ```ts
+ * import {
+ *   AliasNode,
+ *   type AliasedExpression,
+ *   type Expression,
+ *   IdentifierNode
+ * } from 'kysely'
+ *
  * class SomeAliasedExpression<T, A extends string> implements AliasedExpression<T, A> {
  *   #expression: Expression<T>
  *   #alias: A
@@ -140,7 +172,10 @@ export interface AliasableExpression<T> extends Expression<T> {
  *   }
  *
  *   toOperationNode(): AliasNode {
- *     return AliasNode.create(this.#expression.toOperationNode(), IdentifierNode.create(this.#alias))
+ *     return AliasNode.create(
+ *       this.#expression.toOperationNode(),
+ *       IdentifierNode.create(this.#alias)
+ *     )
  *   }
  * }
  * ```

package/dist/esm/helpers/mssql.d.ts

@@ -10,8 +10,26 @@ import { Simplify } from '../util/type-utils.js';
  * The plugin can be installed like this:
  *
  * ```ts
- * const db = new Kysely({
- *   dialect: new MssqlDialect(config),
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
  *   plugins: [new ParseJSONResultsPlugin()]
  * })
  * ```
@@ -19,6 +37,8 @@ import { Simplify } from '../util/type-utils.js';
  * ### Examples
  *
  * ```ts
+ * import { jsonArrayFrom } from 'kysely/helpers/mssql'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -28,14 +48,14 @@ import { Simplify } from '../util/type-utils.js';
  *         .select(['pet.id as pet_id', 'pet.name'])
  *         .whereRef('pet.owner_id', '=', 'person.id')
  *         .orderBy('pet.name')
- *         .modifyEnd(sql`offset 0 rows`)
+ *         .offset(0)
  *     ).as('pets')
  *   ])
  *   .execute()
  *
- * result[0].id
- * result[0].pets[0].pet_id
- * result[0].pets[0].name
+ * result[0]?.id
+ * result[0]?.pets[0]?.pet_id
+ * result[0]?.pets[0]?.name
  * ```
  *
  * The generated SQL (MS SQL Server):
@@ -47,7 +67,7 @@ import { Simplify } from '../util/type-utils.js';
  *     from "pet"
  *     where "pet"."owner_id" = "person"."id"
  *     order by "pet"."name"
- *     offset 0 rows
+ *     offset @1 rows
  *   ) as "agg" for json path, include_null_values), '[]')
  * ) as "pets"
  * from "person"
@@ -65,8 +85,26 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * The plugin can be installed like this:
  *
  * ```ts
- * const db = new Kysely({
- *   dialect: new MssqlDialect(config),
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
  *   plugins: [new ParseJSONResultsPlugin()]
  * })
  * ```
@@ -74,6 +112,8 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * ### Examples
  *
  * ```ts
+ * import { jsonObjectFrom } from 'kysely/helpers/mssql'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [
@@ -87,9 +127,9 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  *   ])
  *   .execute()
  *
- * result[0].id
- * result[0].favorite_pet.pet_id
- * result[0].favorite_pet.name
+ * result[0]?.id
+ * result[0]?.favorite_pet?.pet_id
+ * result[0]?.favorite_pet?.name
  * ```
  *
  * The generated SQL (MS SQL Server):
@@ -116,8 +156,26 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
  * The plugin can be installed like this:
  *
  * ```ts
- * const db = new Kysely({
- *   dialect: new MssqlDialect(config),
+ * import { Kysely, MssqlDialect, ParseJSONResultsPlugin } from 'kysely'
+ * import * as Tarn from 'tarn'
+ * import * as Tedious from 'tedious'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
+ * const db = new Kysely<Database>({
+ *   dialect: new MssqlDialect({
+ *     tarn: { options: { max: 10, min: 0 }, ...Tarn },
+ *     tedious: {
+ *       ...Tedious,
+ *       connectionFactory: () => new Tedious.Connection({
+ *         authentication: {
+ *           options: { password: 'password', userName: 'sa' },
+ *           type: 'default',
+ *         },
+ *         options: { database: 'test', port: 21433, trustServerCertificate: true },
+ *         server: 'localhost',
+ *       }),
+ *     },
+ *   }),
  *   plugins: [new ParseJSONResultsPlugin()]
  * })
  * ```
@@ -125,6 +183,8 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
  * ### Examples
  *
  * ```ts
+ * import { jsonBuildObject } from 'kysely/helpers/mssql'
+ *
  * const result = await db
  *   .selectFrom('person')
  *   .select((eb) => [