kysely 0.19.9 → 0.19.10

package/README.md

@@ -15,7 +15,7 @@ Kysely makes sure you only refer to tables and columns that are visible to the p
 you're writing. The result type only has the selected columns with correct types and aliases. As an
 added bonus you get autocompletion for all that stuff.
 
-As you can see in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
+As shown in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
 column names, aliases and types from selected subqueries, joined subqueries, `with` statements and pretty
 much anything you can think of.
@@ -213,10 +213,11 @@ export async function down(db: Kysely<any>): Promise<void> {
 }
 ```
 
-The `up` function is called when you update your database schema to next version and `down`
+The `up` function is called when you update your database schema to the next version and `down`
 when you go back to previous version. The only argument for the functions is an instance of
-`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
-should never depend on the current code of your app because they need to work even when the app
+`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. 
+
+Migrations should never depend on the current code of your app because they need to work even when the app
 changes. Migrations need to be "frozen in time".
 
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)

package/dist/cjs/operation-node/create-type-node.d.ts

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

package/dist/cjs/operation-node/create-type-node.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const value_list_node_js_1 = require("./value-list-node.js");
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.CreateTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return (0, object_utils_js_1.freeze)({
+            ...createType,
+            enum: value_list_node_js_1.ValueListNode.create(values.map((value) => value_node_js_1.ValueNode.createImmediate(value))),
+        });
+    },
+});

package/dist/cjs/operation-node/drop-type-node.d.ts

@@ -0,0 +1,16 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTypeNode: Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: string): DropTypeNode;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
+}>;

package/dist/cjs/operation-node/drop-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -66,6 +66,8 @@ import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -162,6 +164,8 @@ export declare class OperationNodeTransformer {
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -102,6 +102,8 @@ class OperationNodeTransformer {
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
         SelectModifierNode: this.transformSelectModifier.bind(this),
+        CreateTypeNode: this.transformCreateType.bind(this),
+        DropTypeNode: this.transformDropType.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -603,6 +605,20 @@ class OperationNodeTransformer {
             rawModifier: this.transformNode(node.rawModifier),
         });
     }
+    transformCreateType(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'CreateTypeNode',
+            name: this.transformNode(node.name),
+            enum: this.transformNode(node.enum),
+        });
+    }
+    transformDropType(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'DropTypeNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -66,6 +66,8 @@ import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -138,4 +140,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;
     protected abstract visitSelectModifier(node: SelectModifierNode): void;
+    protected abstract visitCreateType(node: CreateTypeNode): void;
+    protected abstract visitDropType(node: DropTypeNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -75,6 +75,8 @@ class OperationNodeVisitor {
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),
         SelectModifierNode: this.visitSelectModifier.bind(this),
+        CreateTypeNode: this.visitCreateType.bind(this),
+        DropTypeNode: this.visitDropType.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,10 +1,12 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../../operation-node/create-type-node.js';
 import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../../operation-node/drop-type-node.js';
 import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
@@ -24,6 +26,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }

package/dist/cjs/plugin/with-schema/with-schema-transformer.js

@@ -41,6 +41,12 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
     transformDropView(node) {
         return this.#transformRoot(node, (node) => super.transformDropView(node));
     }
+    transformCreateType(node) {
+        return this.#transformRoot(node, (node) => super.transformCreateType(node));
+    }
+    transformDropType(node) {
+        return this.#transformRoot(node, (node) => super.transformDropType(node));
+    }
     transformAlterTable(node) {
         return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }

package/dist/cjs/query-compiler/default-query-compiler.d.ts

@@ -69,6 +69,8 @@ import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -145,6 +147,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
     protected visitSelectModifier(node: SelectModifierNode): void;
+    protected visitCreateType(node: CreateTypeNode): void;
+    protected visitDropType(node: DropTypeNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -791,6 +791,21 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
     }
+    visitCreateType(node) {
+        this.append('create type ');
+        this.visitNode(node.name);
+        if (node.enum) {
+            this.append(' as enum ');
+            this.visitNode(node.enum);
+        }
+    }
+    visitDropType(node) {
+        this.append('drop type ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
+        this.visitNode(node.name);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/cjs/query-compiler/query-compiler.d.ts

@@ -2,15 +2,17 @@ import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../operation-node/create-index-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode;
+export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

package/dist/cjs/schema/create-type-builder.d.ts

@@ -0,0 +1,19 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+export declare class CreateTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: CreateTypeBuilderProps);
+    toOperationNode(): CreateTypeNode;
+    asEnum(values: string[]): CreateTypeBuilder;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface CreateTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTypeNode: CreateTypeNode;
+}

package/dist/cjs/schema/create-type-builder.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeBuilder = void 0;
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const create_type_node_js_1 = require("../operation-node/create-type-node.js");
+class CreateTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.createTypeNode, this.#props.queryId);
+    }
+    asEnum(values) {
+        return new CreateTypeBuilder({
+            ...this.#props,
+            createTypeNode: create_type_node_js_1.CreateTypeNode.cloneWithEnum(this.#props.createTypeNode, values),
+        });
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.CreateTypeBuilder = CreateTypeBuilder;
+(0, prevent_await_js_1.preventAwait)(CreateTypeBuilder, "don't await CreateTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/drop-type-builder.d.ts

@@ -0,0 +1,19 @@
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+export declare class DropTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: DropTypeBuilderProps);
+    ifExists(): DropTypeBuilder;
+    toOperationNode(): DropTypeNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface DropTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTypeNode: DropTypeNode;
+}

package/dist/cjs/schema/drop-type-builder.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTypeBuilder = void 0;
+const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class DropTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    ifExists() {
+        return new DropTypeBuilder({
+            ...this.#props,
+            dropTypeNode: drop_type_node_js_1.DropTypeNode.cloneWith(this.#props.dropTypeNode, {
+                ifExists: true,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.dropTypeNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.DropTypeBuilder = DropTypeBuilder;
+(0, prevent_await_js_1.preventAwait)(DropTypeBuilder, "don't await DropTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/schema.d.ts

@@ -9,6 +9,8 @@ import { DropTableBuilder } from './drop-table-builder.js';
 import { CreateViewBuilder } from './create-view-builder.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -170,6 +172,36 @@ export declare class SchemaModule {
      * ```
      */
     dropView(viewName: string): DropViewBuilder;
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName: string): CreateTypeBuilder;
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/cjs/schema/schema.js

@@ -22,6 +22,10 @@ const create_view_builder_js_1 = require("./create-view-builder.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
 const drop_view_builder_js_1 = require("./drop-view-builder.js");
 const drop_view_node_js_1 = require("../operation-node/drop-view-node.js");
+const create_type_builder_js_1 = require("./create-type-builder.js");
+const drop_type_builder_js_1 = require("./drop-type-builder.js");
+const create_type_node_js_1 = require("../operation-node/create-type-node.js");
+const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
 /**
  * Provides methods for building database schema.
  */
@@ -239,6 +243,48 @@ class SchemaModule {
             dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
         });
     }
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName) {
+        return new create_type_builder_js_1.CreateTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            createTypeNode: create_type_node_js_1.CreateTypeNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName) {
+        return new drop_type_builder_js_1.DropTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            dropTypeNode: drop_type_node_js_1.DropTypeNode.create(viewName),
+        });
+    }
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/esm/operation-node/create-type-node.d.ts

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

package/dist/esm/operation-node/create-type-node.js

@@ -0,0 +1,25 @@
+/// <reference types="./create-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+import { ValueListNode } from './value-list-node.js';
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const CreateTypeNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return freeze({
+            ...createType,
+            enum: ValueListNode.create(values.map((value) => ValueNode.createImmediate(value))),
+        });
+    },
+});

package/dist/esm/operation-node/drop-type-node.d.ts

@@ -0,0 +1,16 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTypeNode: Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: string): DropTypeNode;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
+}>;

package/dist/esm/operation-node/drop-type-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./drop-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const DropTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'DropTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return freeze({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -66,6 +66,8 @@ import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -162,6 +164,8 @@ export declare class OperationNodeTransformer {
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -100,6 +100,8 @@ export class OperationNodeTransformer {
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
         SelectModifierNode: this.transformSelectModifier.bind(this),
+        CreateTypeNode: this.transformCreateType.bind(this),
+        DropTypeNode: this.transformDropType.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -601,6 +603,20 @@ export class OperationNodeTransformer {
             rawModifier: this.transformNode(node.rawModifier),
         });
     }
+    transformCreateType(node) {
+        return requireAllProps({
+            kind: 'CreateTypeNode',
+            name: this.transformNode(node.name),
+            enum: this.transformNode(node.enum),
+        });
+    }
+    transformDropType(node) {
+        return requireAllProps({
+            kind: 'DropTypeNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -66,6 +66,8 @@ import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -138,4 +140,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;
     protected abstract visitSelectModifier(node: SelectModifierNode): void;
+    protected abstract visitCreateType(node: CreateTypeNode): void;
+    protected abstract visitDropType(node: DropTypeNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -73,6 +73,8 @@ export class OperationNodeVisitor {
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),
         SelectModifierNode: this.visitSelectModifier.bind(this),
+        CreateTypeNode: this.visitCreateType.bind(this),
+        DropTypeNode: this.visitDropType.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,10 +1,12 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../../operation-node/create-type-node.js';
 import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../../operation-node/drop-type-node.js';
 import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
@@ -24,6 +26,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -39,6 +39,12 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
     transformDropView(node) {
         return this.#transformRoot(node, (node) => super.transformDropView(node));
     }
+    transformCreateType(node) {
+        return this.#transformRoot(node, (node) => super.transformCreateType(node));
+    }
+    transformDropType(node) {
+        return this.#transformRoot(node, (node) => super.transformDropType(node));
+    }
     transformAlterTable(node) {
         return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -69,6 +69,8 @@ import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -145,6 +147,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
     protected visitSelectModifier(node: SelectModifierNode): void;
+    protected visitCreateType(node: CreateTypeNode): void;
+    protected visitDropType(node: DropTypeNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -789,6 +789,21 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
     }
+    visitCreateType(node) {
+        this.append('create type ');
+        this.visitNode(node.name);
+        if (node.enum) {
+            this.append(' as enum ');
+            this.visitNode(node.enum);
+        }
+    }
+    visitDropType(node) {
+        this.append('drop type ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
+        this.visitNode(node.name);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/query-compiler/query-compiler.d.ts

@@ -2,15 +2,17 @@ import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../operation-node/create-index-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode;
+export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

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

@@ -0,0 +1,19 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+export declare class CreateTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: CreateTypeBuilderProps);
+    toOperationNode(): CreateTypeNode;
+    asEnum(values: string[]): CreateTypeBuilder;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface CreateTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTypeNode: CreateTypeNode;
+}

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

@@ -0,0 +1,26 @@
+/// <reference types="./create-type-builder.d.ts" />
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+export class CreateTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.createTypeNode, this.#props.queryId);
+    }
+    asEnum(values) {
+        return new CreateTypeBuilder({
+            ...this.#props,
+            createTypeNode: CreateTypeNode.cloneWithEnum(this.#props.createTypeNode, values),
+        });
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(CreateTypeBuilder, "don't await CreateTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-type-builder.d.ts

@@ -0,0 +1,19 @@
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+export declare class DropTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: DropTypeBuilderProps);
+    ifExists(): DropTypeBuilder;
+    toOperationNode(): DropTypeNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface DropTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTypeNode: DropTypeNode;
+}

package/dist/esm/schema/drop-type-builder.js

@@ -0,0 +1,28 @@
+/// <reference types="./drop-type-builder.d.ts" />
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+export class DropTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    ifExists() {
+        return new DropTypeBuilder({
+            ...this.#props,
+            dropTypeNode: DropTypeNode.cloneWith(this.#props.dropTypeNode, {
+                ifExists: true,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.dropTypeNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(DropTypeBuilder, "don't await DropTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/schema.d.ts

@@ -9,6 +9,8 @@ import { DropTableBuilder } from './drop-table-builder.js';
 import { CreateViewBuilder } from './create-view-builder.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -170,6 +172,36 @@ export declare class SchemaModule {
      * ```
      */
     dropView(viewName: string): DropViewBuilder;
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName: string): CreateTypeBuilder;
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/esm/schema/schema.js

@@ -20,6 +20,10 @@ import { CreateViewBuilder } from './create-view-builder.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 /**
  * Provides methods for building database schema.
  */
@@ -237,6 +241,48 @@ export class SchemaModule {
             dropViewNode: DropViewNode.create(viewName),
         });
     }
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName) {
+        return new CreateTypeBuilder({
+            queryId: createQueryId(),
+            executor: this.#executor,
+            createTypeNode: CreateTypeNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName) {
+        return new DropTypeBuilder({
+            queryId: createQueryId(),
+            executor: this.#executor,
+            dropTypeNode: DropTypeNode.create(viewName),
+        });
+    }
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.9",
+  "version": "0.19.10",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",