kysely 0.16.9 → 0.17.1

package/dist/esm/raw-builder/sql.js

@@ -0,0 +1,151 @@
+/// <reference types="./sql.d.ts" />
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { parseStringReference } from '../parser/reference-parser.js';
+import { parseTable } from '../parser/table-parser.js';
+import { parseValueExpression } from '../parser/value-parser.js';
+import { createQueryId } from '../util/query-id.js';
+import { RawBuilder } from './raw-builder.js';
+/**
+ * Template tag for creating raw SQL snippets and queries.
+ *
+ * ```ts
+ * import { sql } from 'kysely'
+ *
+ * const id = 123
+ *
+ * const snippet = sql<Person[]>`select * from person where id = ${id}`
+ * ```
+ *
+ * Substitutions (the things inside `${}`) are automatically passed to the database
+ * as parameters and are NOT interpolated to the SQL string. There's no need to worry
+ * about SQL injection vulnerabilities.
+ *
+ * If you need your substitutions to be interpreted as identifiers, value literals or
+ * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
+ * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
+ *
+ * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
+ * something can't be done using the Kysely API, you should be able to drop down to
+ * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
+ * of methods:
+ *
+ * ```ts
+ * const persons = await db
+ *   .selectFrom('person')
+ *   .select(
+ *     // If you use `sql` in a select statement, remember to call the `as`
+ *     // method to give it an alias. Otherwise Kysely is not able to add
+ *     // the column to the result type.
+ *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+ *   )
+ *   .where(sql`birthdate between ${date1} and ${date2}`)
+ *   // Here we assume we have list of nicknames for the person
+ *   // (a list of strings) and we use the PostgreSQL `@>` operator
+ *   // to test if all of them are valid nicknames for the user.
+ *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
+ *   .orderBy(sql`concat(first_name, ' ', last_name)`)
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select concat(first_name, ' ', last_name) as "full_name"
+ * from "person"
+ * where birthdate between $1 and $2
+ * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
+ * order by concate(first_name, ' ', last_name)
+ * ```
+ *
+ * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
+ * instance as the only argument:
+ *
+ * ```ts
+ * const result = await sql<Person[]>`select * from person`.execute(db)
+ * ```
+ *
+ * You can merge other `sql` expressions and queries using substitutions:
+ *
+ * ```ts
+ * const petName = db.selectFrom('pet').select('name').limit(1)
+ * const fullName = sql`concat(first_name, ' ', last_name)`
+ *
+ * sql`
+ *   select ${fullName} as full_name, ${petName} as pet_name
+ *   from person
+ * `
+ * ```
+ *
+ * Substitutions also handle {@link ExpressionBuilder.ref},
+ * {@link DynamicModule.ref} and pretty much anything else you
+ * throw at it. Here's an example of calling a function in a
+ * type-safe way:
+ *
+ * ```ts
+ * db.selectFrom('person')
+ *   .select([
+ *     'first_name',
+ *     'last_name',
+ *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *   ])
+ * ```
+ *
+ * don't know if that amount of ceremony is worth the small increase in
+ * type-safety though... But it's possible.
+ */
+export const sql = Object.assign((sqlFragments, ...parameters) => {
+    return new RawBuilder({
+        queryId: createQueryId(),
+        rawNode: RawNode.create(sqlFragments, parameters?.map(parseValueExpression) ?? []),
+    });
+}, {
+    ref(columnReference) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
+        });
+    },
+    table(tableReference) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseTable(tableReference)),
+        });
+    },
+    id(...ids) {
+        const fragments = new Array(ids.length + 1).fill('.');
+        fragments[0] = '';
+        fragments[fragments.length - 1] = '';
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
+        });
+    },
+    literal(value) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
+        });
+    },
+    raw(sql) {
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithSql(sql),
+        });
+    },
+    join(array, separator = sql `, `) {
+        const nodes = new Array(2 * array.length - 1);
+        const sep = separator.toOperationNode();
+        for (let i = 0; i < array.length; ++i) {
+            nodes[2 * i] = parseValueExpression(array[i]);
+            if (i !== array.length - 1) {
+                nodes[2 * i + 1] = sep;
+            }
+        }
+        return new RawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChildren(nodes),
+        });
+    },
+});

package/dist/esm/schema/alter-table-builder.d.ts

@@ -142,15 +142,17 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .execute()
      * ```
      *
-     * Raw expressions are also supported:
+     * Raw {@link sql} expressions are also supported:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn(
      *     'number_of_legs',
      *     'integer',
-     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *     (col) => col.defaultTo(sql`any SQL here`)
      *   )
      *   .execute()
      * ```
@@ -162,10 +164,12 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(db.raw('number_of_legs < 5'))
+     *     col.check(sql`number_of_legs < 5`)
      *   )
      *   .execute()
      * ```
@@ -177,10 +181,12 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
      *   )
      *   .execute()
      * ```
@@ -300,15 +306,17 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .execute()
      * ```
      *
-     * Raw expressions are also supported:
+     * Raw {@link sql} expressions are also supported:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn(
      *     'number_of_legs',
      *     'integer',
-     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *     (col) => col.defaultTo(sql`any SQL here`)
      *   )
      *   .execute()
      * ```
@@ -320,10 +328,12 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(db.raw('number_of_legs < 5'))
+     *     col.check(sql`number_of_legs < 5`)
      *   )
      *   .execute()
      * ```
@@ -335,10 +345,12 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
      *   )
      *   .execute()
      * ```

package/dist/esm/schema/alter-table-builder.js

@@ -7,7 +7,6 @@ import { DataTypeNode, } from '../operation-node/data-type-node.js';
 import { DropColumnNode } from '../operation-node/drop-column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { RenameColumnNode } from '../operation-node/rename-column-node.js';
-import { TableNode } from '../operation-node/table-node.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionBuilder, } from './column-definition-builder.js';
@@ -20,6 +19,7 @@ import { CheckConstraintNode } from '../operation-node/check-constraint-node.js'
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+import { parseTable } from '../parser/table-parser.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -32,7 +32,7 @@ export class AlterTableBuilder {
         return new AlterTableExecutor({
             ...this.#props,
             alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
-                renameTo: TableNode.create(newTableName),
+                renameTo: parseTable(newTableName),
             }),
         });
     }
@@ -102,7 +102,7 @@ export class AlterTableBuilder {
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
         return new AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,
-            constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
+            constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
 }

package/dist/esm/schema/column-definition-builder.d.ts

@@ -83,15 +83,17 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      *
-     * Raw expressions are also supported:
+     * Raw {@link sql} expressions are also supported:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn(
      *     'number_of_legs',
      *     'integer',
-     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *     (col) => col.defaultTo(sql`any SQL here`)
      *   )
      *   .execute()
      * ```
@@ -103,10 +105,12 @@ export interface ColumnDefinitionBuilderInterface {
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(db.raw('number_of_legs < 5'))
+     *     col.check(sql`number_of_legs < 5`)
      *   )
      *   .execute()
      * ```
@@ -118,10 +122,12 @@ export interface ColumnDefinitionBuilderInterface {
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
      *   )
      *   .execute()
      * ```
@@ -235,15 +241,17 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .execute()
      * ```
      *
-     * Raw expressions are also supported:
+     * Raw {@link sql} expressions are also supported:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn(
      *     'number_of_legs',
      *     'integer',
-     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *     (col) => col.defaultTo(sql`any SQL here`)
      *   )
      *   .execute()
      * ```
@@ -255,10 +263,12 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('pet')
      *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(db.raw('number_of_legs < 5'))
+     *     col.check(sql`number_of_legs < 5`)
      *   )
      *   .execute()
      * ```
@@ -270,10 +280,12 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
      *   )
      *   .execute()
      * ```

package/dist/esm/schema/create-index-builder.d.ts

@@ -34,10 +34,12 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db.schema
      *   .createIndex('person_first_name_index')
      *   .on('person')
-     *   .expression(db.raw('first_name COLLATE "fi_FI"'))
+     *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
      */

package/dist/esm/schema/create-index-builder.js

@@ -65,10 +65,12 @@ export class CreateIndexBuilder {
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db.schema
      *   .createIndex('person_first_name_index')
      *   .on('person')
-     *   .expression(db.raw('first_name COLLATE "fi_FI"'))
+     *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
      */

package/dist/esm/schema/create-table-builder.d.ts

@@ -39,13 +39,15 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', db.raw('customtype'))
+     *   .addColumn('data', sql`customtype`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
@@ -111,7 +113,9 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ### Examples
      *
      * ```ts
-     * addCheckConstraint('check_legs', db.raw('number_of_legs < 5'))
+     * import { sql } from 'kysely'
+     *
+     * addCheckConstraint('check_legs', sql`number_of_legs < 5`)
      * ```
      */
     addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): CreateTableBuilder<TB, C>;

package/dist/esm/schema/create-table-builder.js

@@ -6,12 +6,12 @@ import { ColumnDefinitionBuilder } from './column-definition-builder.js';
 import { freeze, noop } from '../util/object-utils.js';
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { TableNode } from '../operation-node/table-node.js';
 import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
 import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 import { PrimaryConstraintNode } from '../operation-node/primary-constraint-node.js';
 import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js';
+import { parseTable } from '../parser/table-parser.js';
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -66,13 +66,15 @@ export class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', db.raw('customtype'))
+     *   .addColumn('data', sql`customtype`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
@@ -154,7 +156,9 @@ export class CreateTableBuilder {
      * ### Examples
      *
      * ```ts
-     * addCheckConstraint('check_legs', db.raw('number_of_legs < 5'))
+     * import { sql } from 'kysely'
+     *
+     * addCheckConstraint('check_legs', sql`number_of_legs < 5`)
      * ```
      */
     addCheckConstraint(constraintName, checkExpression) {
@@ -193,7 +197,7 @@ export class CreateTableBuilder {
      * ```
      */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns, build = noop) {
-        const builder = build(new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName)));
+        const builder = build(new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)));
         return new CreateTableBuilder({
             ...this.#props,
             createTableNode: CreateTableNode.cloneWithConstraint(this.#props.createTableNode, builder.toOperationNode()),

package/dist/esm/schema/create-view-builder.d.ts

@@ -26,9 +26,9 @@ export declare class CreateViewBuilder implements OperationNodeSource, Compilabl
      *
      * WARNING!
      * Some dialects don't support parameterized queries in DDL statements and therefore
-     * the query or `raw` expression passed here is interpolated into a single string
-     * opening an SQL injection vulnerability. DO NOT pass unchecked user input into
-     * the query or `raw` expression passed to this method!
+     * the query or raw {@link sql } expression passed here is interpolated into a single
+     * string opening an SQL injection vulnerability. DO NOT pass unchecked user input
+     * into the query or raw expression passed to this method!
      */
     as(query: AnySelectQueryBuilder | AnyRawBuilder): CreateViewBuilder;
     toOperationNode(): CreateViewNode;

package/dist/esm/schema/create-view-builder.js

@@ -62,9 +62,9 @@ export class CreateViewBuilder {
      *
      * WARNING!
      * Some dialects don't support parameterized queries in DDL statements and therefore
-     * the query or `raw` expression passed here is interpolated into a single string
-     * opening an SQL injection vulnerability. DO NOT pass unchecked user input into
-     * the query or `raw` expression passed to this method!
+     * the query or raw {@link sql } expression passed here is interpolated into a single
+     * string opening an SQL injection vulnerability. DO NOT pass unchecked user input
+     * into the query or raw expression passed to this method!
      */
     as(query) {
         const queryNode = query

package/dist/esm/util/query-id.js

@@ -1,8 +1,14 @@
 /// <reference types="./query-id.d.ts" />
-import { freeze } from './object-utils.js';
 import { randomString } from './random-string.js';
 export function createQueryId() {
-    return freeze({
-        queryId: randomString(8),
-    });
+    return new LazyQueryId();
+}
+class LazyQueryId {
+    #queryId;
+    get queryId() {
+        if (this.#queryId === undefined) {
+            this.#queryId = randomString(8);
+        }
+        return this.#queryId;
+    }
 }

package/dist/esm/util/random-string.js

@@ -1,5 +1,68 @@
 /// <reference types="./random-string.d.ts" />
-const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+const CHARS = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+];
 export function randomString(length) {
     let chars = '';
     for (let i = 0; i < length; ++i) {
@@ -8,5 +71,5 @@ export function randomString(length) {
     return chars;
 }
 function randomChar() {
-    return CHARS[Math.floor(Math.random() * CHARS.length)];
+    return CHARS[~~(Math.random() * CHARS.length)];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.16.9",
+  "version": "0.17.1",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -47,22 +47,22 @@
     "@types/node": "^16.11.9"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.4.1",
+    "@types/better-sqlite3": "^7.4.2",
     "@types/chai": "^4.3.0",
     "@types/chai-subset": "^1.3.3",
-    "@types/mocha": "^9.0.0",
-    "@types/pg": "^8.6.1",
-    "better-sqlite3": "^7.4.5",
-    "chai": "^4.3.4",
+    "@types/mocha": "^9.1.0",
+    "@types/pg": "^8.6.4",
+    "better-sqlite3": "^7.5.0",
+    "chai": "^4.3.6",
     "chai-subset": "^1.6.0",
-    "esbuild": "^0.14.11",
-    "mocha": "^9.1.3",
+    "esbuild": "^0.14.22",
+    "mocha": "^9.2.0",
     "mysql2": "^2.3.3",
-    "pg": "^8.7.1",
-    "playwright": "^1.17.2",
+    "pg": "^8.7.3",
+    "playwright": "^1.19.1",
     "prettier": "^2.5.1",
-    "tsd": "^0.19.0",
-    "typedoc": "^0.22.10",
-    "typescript": "4.5.3"
+    "tsd": "^0.19.1",
+    "typedoc": "^0.22.11",
+    "typescript": "4.5.5"
   }
 }