noormme 1.0.0

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

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

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

@@ -0,0 +1,19 @@
+import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import { TableNode } from './table-node.js';
+export type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
+export interface DropIndexNode extends OperationNode {
+    readonly kind: 'DropIndexNode';
+    readonly name: SchemableIdentifierNode;
+    readonly table?: TableNode;
+    readonly ifExists?: boolean;
+    readonly cascade?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropIndexNode: Readonly<{
+    is(node: OperationNode): node is DropIndexNode;
+    create(name: string, params?: DropIndexNodeProps): DropIndexNode;
+    cloneWith(dropIndex: DropIndexNode, props: DropIndexNodeProps): DropIndexNode;
+}>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropIndexNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const schemable_identifier_node_js_1 = require("./schemable-identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropIndexNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropIndexNode';
+    },
+    create(name, params) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropIndexNode',
+            name: schemable_identifier_node_js_1.SchemableIdentifierNode.create(name),
+            ...params,
+        });
+    },
+    cloneWith(dropIndex, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropIndex,
+            ...props,
+        });
+    },
+});

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+export type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+export interface DropTableNode extends OperationNode {
+    readonly kind: 'DropTableNode';
+    readonly table: TableNode;
+    readonly ifExists?: boolean;
+    readonly cascade?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTableNode: Readonly<{
+    is(node: OperationNode): node is DropTableNode;
+    create(table: TableNode, params?: DropTablexNodeParams): DropTableNode;
+    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
+}>;

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

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

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.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,
+        });
+    },
+    cloneWith(dropType, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropType,
+            ...params,
+        });
+    },
+});

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

@@ -0,0 +1,18 @@
+import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
+export type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
+export interface DropViewNode extends OperationNode {
+    readonly kind: 'DropViewNode';
+    readonly name: SchemableIdentifierNode;
+    readonly ifExists?: boolean;
+    readonly materialized?: boolean;
+    readonly cascade?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropViewNode: Readonly<{
+    is(node: OperationNode): node is DropViewNode;
+    create(name: string): DropViewNode;
+    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): DropViewNode;
+}>;

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

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

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

@@ -0,0 +1,14 @@
+import { ExplainFormat } from '../util/explainable.js';
+import { OperationNode } from './operation-node.js';
+export interface ExplainNode extends OperationNode {
+    readonly kind: 'ExplainNode';
+    readonly format?: ExplainFormat;
+    readonly options?: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const ExplainNode: Readonly<{
+    is(node: OperationNode): node is ExplainNode;
+    create(format?: ExplainFormat, options?: OperationNode): ExplainNode;
+}>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplainNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ExplainNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ExplainNode';
+    },
+    create(format, options) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ExplainNode',
+            format,
+            options,
+        });
+    },
+});

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

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+import { ValueNode } from './value-node.js';
+export type FetchModifier = 'only' | 'with ties';
+export interface FetchNode extends OperationNode {
+    readonly kind: 'FetchNode';
+    readonly rowCount: ValueNode;
+    readonly modifier: FetchModifier;
+}
+/**
+ * @internal
+ */
+export declare const FetchNode: {
+    is(node: OperationNode): node is FetchNode;
+    create(rowCount: number | bigint, modifier: FetchModifier): FetchNode;
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchNode = void 0;
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.FetchNode = {
+    is(node) {
+        return node.kind === 'FetchNode';
+    },
+    create(rowCount, modifier) {
+        return {
+            kind: 'FetchNode',
+            rowCount: value_node_js_1.ValueNode.create(rowCount),
+            modifier,
+        };
+    },
+};

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -0,0 +1,33 @@
+import { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
+import { TableNode } from './table-node.js';
+export type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
+export interface ForeignKeyConstraintNode extends OperationNode {
+    readonly kind: 'ForeignKeyConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
+    readonly name?: IdentifierNode;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const ForeignKeyConstraintNode: Readonly<{
+    is(node: OperationNode): node is ForeignKeyConstraintNode;
+    create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
+        name?: IdentifierNode;
+        onDelete?: OnModifyForeignAction;
+        onUpdate?: OnModifyForeignAction;
+        deferrable?: boolean;
+        initiallyDeferred?: boolean;
+        kind: "ForeignKeyConstraintNode";
+        columns: ReadonlyArray<ColumnNode>;
+        references: ReferencesNode;
+    }>;
+}>;

package/dist/cjs/operation-node/foreign-key-constraint-node.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeyConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const references_node_js_1 = require("./references-node.js");
+/**
+ * @internal
+ */
+exports.ForeignKeyConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ForeignKeyConstraintNode';
+    },
+    create(sourceColumns, targetTable, targetColumns, constraintName) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ForeignKeyConstraintNode',
+            columns: sourceColumns,
+            references: references_node_js_1.ReferencesNode.create(targetTable, targetColumns),
+            name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+});

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface FromNode extends OperationNode {
+    readonly kind: 'FromNode';
+    readonly froms: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const FromNode: Readonly<{
+    is(node: OperationNode): node is FromNode;
+    create(froms: ReadonlyArray<OperationNode>): FromNode;
+    cloneWithFroms(from: FromNode, froms: ReadonlyArray<OperationNode>): FromNode;
+}>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.FromNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'FromNode';
+    },
+    create(froms) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'FromNode',
+            froms: (0, object_utils_js_1.freeze)(froms),
+        });
+    },
+    cloneWithFroms(from, froms) {
+        return (0, object_utils_js_1.freeze)({
+            ...from,
+            froms: (0, object_utils_js_1.freeze)([...from.froms, ...froms]),
+        });
+    },
+});

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface FunctionNode extends OperationNode {
+    readonly kind: 'FunctionNode';
+    readonly func: string;
+    readonly arguments: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const FunctionNode: Readonly<{
+    is(node: OperationNode): node is FunctionNode;
+    create(func: string, args: ReadonlyArray<OperationNode>): FunctionNode;
+}>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.FunctionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'FunctionNode';
+    },
+    create(func, args) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'FunctionNode',
+            func,
+            arguments: args,
+        });
+    },
+});

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

@@ -0,0 +1,19 @@
+import { OperationNode } from './operation-node.js';
+export type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
+export interface GeneratedNode extends OperationNode {
+    readonly kind: 'GeneratedNode';
+    readonly byDefault?: boolean;
+    readonly always?: boolean;
+    readonly identity?: boolean;
+    readonly stored?: boolean;
+    readonly expression?: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedNode: Readonly<{
+    is(node: OperationNode): node is GeneratedNode;
+    create(params: GeneratedNodeParams): GeneratedNode;
+    createWithExpression(expression: OperationNode): GeneratedNode;
+    cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
+}>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.GeneratedNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GeneratedNode';
+    },
+    create(params) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedNode',
+            ...params,
+        });
+    },
+    createWithExpression(expression) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedNode',
+            always: true,
+            expression,
+        });
+    },
+    cloneWith(node, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...params,
+        });
+    },
+});

package/dist/cjs/operation-node/group-by-item-node.d.ts

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface GroupByItemNode extends OperationNode {
+    readonly kind: 'GroupByItemNode';
+    readonly groupBy: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const GroupByItemNode: Readonly<{
+    is(node: OperationNode): node is GroupByItemNode;
+    create(groupBy: OperationNode): GroupByItemNode;
+}>;

package/dist/cjs/operation-node/group-by-item-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupByItemNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.GroupByItemNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GroupByItemNode';
+    },
+    create(groupBy) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GroupByItemNode',
+            groupBy,
+        });
+    },
+});

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { GroupByItemNode } from './group-by-item-node.js';
+export interface GroupByNode extends OperationNode {
+    readonly kind: 'GroupByNode';
+    readonly items: ReadonlyArray<GroupByItemNode>;
+}
+/**
+ * @internal
+ */
+export declare const GroupByNode: Readonly<{
+    is(node: OperationNode): node is GroupByNode;
+    create(items: ReadonlyArray<GroupByItemNode>): GroupByNode;
+    cloneWithItems(groupBy: GroupByNode, items: ReadonlyArray<GroupByItemNode>): GroupByNode;
+}>;

package/dist/cjs/operation-node/group-by-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupByNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.GroupByNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GroupByNode';
+    },
+    create(items) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GroupByNode',
+            items: (0, object_utils_js_1.freeze)(items),
+        });
+    },
+    cloneWithItems(groupBy, items) {
+        return (0, object_utils_js_1.freeze)({
+            ...groupBy,
+            items: (0, object_utils_js_1.freeze)([...groupBy.items, ...items]),
+        });
+    },
+});

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

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface HavingNode extends OperationNode {
+    readonly kind: 'HavingNode';
+    readonly having: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const HavingNode: Readonly<{
+    is(node: OperationNode): node is HavingNode;
+    create(filter: OperationNode): HavingNode;
+    cloneWithOperation(havingNode: HavingNode, operator: "And" | "Or", operation: OperationNode): HavingNode;
+}>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HavingNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const and_node_js_1 = require("./and-node.js");
+const or_node_js_1 = require("./or-node.js");
+/**
+ * @internal
+ */
+exports.HavingNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'HavingNode';
+    },
+    create(filter) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'HavingNode',
+            having: filter,
+        });
+    },
+    cloneWithOperation(havingNode, operator, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...havingNode,
+            having: operator === 'And'
+                ? and_node_js_1.AndNode.create(havingNode.having, operation)
+                : or_node_js_1.OrNode.create(havingNode.having, operation),
+        });
+    },
+});

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

@@ -0,0 +1,12 @@
+import { OperationNode } from './operation-node.js';
+export interface IdentifierNode extends OperationNode {
+    readonly kind: 'IdentifierNode';
+    readonly name: string;
+}
+/**
+ * @internal
+ */
+export declare const IdentifierNode: Readonly<{
+    is(node: OperationNode): node is IdentifierNode;
+    create(name: string): IdentifierNode;
+}>;

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

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