@constructive-sdk/cli 0.2.0

package/esm/public/orm/models/tableModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * TableModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { TableModuleWithRelations, TableModuleSelect, TableModuleFilter, TableModuleOrderBy, CreateTableModuleInput, TableModulePatch } from '../input-types';
+export declare class TableModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends TableModuleSelect>(args: FindManyArgs<S, TableModuleFilter, TableModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        tableModules: ConnectionResult<InferSelectResult<TableModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends TableModuleSelect>(args: FindFirstArgs<S, TableModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        tableModules: {
+            nodes: InferSelectResult<TableModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends TableModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        tableModule: InferSelectResult<TableModuleWithRelations, S> | null;
+    }>;
+    create<S extends TableModuleSelect>(args: CreateArgs<S, CreateTableModuleInput['tableModule']> & {
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        createTableModule: {
+            tableModule: InferSelectResult<TableModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends TableModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, TableModulePatch> & {
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        updateTableModule: {
+            tableModule: InferSelectResult<TableModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends TableModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, TableModuleSelect>): QueryBuilder<{
+        deleteTableModule: {
+            tableModule: InferSelectResult<TableModuleWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/tableModule.js

@@ -0,0 +1,94 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class TableModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('TableModule', 'tableModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'TableModuleFilter', 'TableModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableModule',
+            fieldName: 'tableModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('TableModule', 'tableModules', args.select, {
+            where: args?.where,
+        }, 'TableModuleFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableModule',
+            fieldName: 'tableModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('TableModule', 'tableModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'TableModuleFilter', 'TableModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableModule',
+            fieldName: 'tableModule',
+            document,
+            variables,
+            transform: (data) => ({
+                tableModule: data.tableModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('TableModule', 'createTableModule', 'tableModule', args.select, args.data, 'CreateTableModuleInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableModule',
+            fieldName: 'createTableModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('TableModule', 'updateTableModule', 'tableModule', args.select, args.where.id, args.data, 'UpdateTableModuleInput', 'id', 'tableModulePatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableModule',
+            fieldName: 'updateTableModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('TableModule', 'deleteTableModule', 'tableModule', args.where.id, 'DeleteTableModuleInput', 'id', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableModule',
+            fieldName: 'deleteTableModule',
+            document,
+            variables,
+        });
+    }
+}

package/esm/public/orm/models/tableTemplateModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * TableTemplateModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { TableTemplateModuleWithRelations, TableTemplateModuleSelect, TableTemplateModuleFilter, TableTemplateModuleOrderBy, CreateTableTemplateModuleInput, TableTemplateModulePatch } from '../input-types';
+export declare class TableTemplateModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends TableTemplateModuleSelect>(args: FindManyArgs<S, TableTemplateModuleFilter, TableTemplateModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        tableTemplateModules: ConnectionResult<InferSelectResult<TableTemplateModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends TableTemplateModuleSelect>(args: FindFirstArgs<S, TableTemplateModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        tableTemplateModules: {
+            nodes: InferSelectResult<TableTemplateModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends TableTemplateModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        tableTemplateModule: InferSelectResult<TableTemplateModuleWithRelations, S> | null;
+    }>;
+    create<S extends TableTemplateModuleSelect>(args: CreateArgs<S, CreateTableTemplateModuleInput['tableTemplateModule']> & {
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        createTableTemplateModule: {
+            tableTemplateModule: InferSelectResult<TableTemplateModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends TableTemplateModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, TableTemplateModulePatch> & {
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        updateTableTemplateModule: {
+            tableTemplateModule: InferSelectResult<TableTemplateModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends TableTemplateModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
+        deleteTableTemplateModule: {
+            tableTemplateModule: InferSelectResult<TableTemplateModuleWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/tableTemplateModule.js

@@ -0,0 +1,94 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class TableTemplateModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('TableTemplateModule', 'tableTemplateModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'TableTemplateModuleFilter', 'TableTemplateModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableTemplateModule',
+            fieldName: 'tableTemplateModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('TableTemplateModule', 'tableTemplateModules', args.select, {
+            where: args?.where,
+        }, 'TableTemplateModuleFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableTemplateModule',
+            fieldName: 'tableTemplateModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('TableTemplateModule', 'tableTemplateModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'TableTemplateModuleFilter', 'TableTemplateModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TableTemplateModule',
+            fieldName: 'tableTemplateModule',
+            document,
+            variables,
+            transform: (data) => ({
+                tableTemplateModule: data.tableTemplateModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('TableTemplateModule', 'createTableTemplateModule', 'tableTemplateModule', args.select, args.data, 'CreateTableTemplateModuleInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableTemplateModule',
+            fieldName: 'createTableTemplateModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('TableTemplateModule', 'updateTableTemplateModule', 'tableTemplateModule', args.select, args.where.id, args.data, 'UpdateTableTemplateModuleInput', 'id', 'tableTemplateModulePatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableTemplateModule',
+            fieldName: 'updateTableTemplateModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('TableTemplateModule', 'deleteTableTemplateModule', 'tableTemplateModule', args.where.id, 'DeleteTableTemplateModuleInput', 'id', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TableTemplateModule',
+            fieldName: 'deleteTableTemplateModule',
+            document,
+            variables,
+        });
+    }
+}

package/esm/public/orm/models/trigger.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Trigger model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { TriggerWithRelations, TriggerSelect, TriggerFilter, TriggerOrderBy, CreateTriggerInput, TriggerPatch } from '../input-types';
+export declare class TriggerModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends TriggerSelect>(args: FindManyArgs<S, TriggerFilter, TriggerOrderBy> & {
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        triggers: ConnectionResult<InferSelectResult<TriggerWithRelations, S>>;
+    }>;
+    findFirst<S extends TriggerSelect>(args: FindFirstArgs<S, TriggerFilter> & {
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        triggers: {
+            nodes: InferSelectResult<TriggerWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends TriggerSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        trigger: InferSelectResult<TriggerWithRelations, S> | null;
+    }>;
+    create<S extends TriggerSelect>(args: CreateArgs<S, CreateTriggerInput['trigger']> & {
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        createTrigger: {
+            trigger: InferSelectResult<TriggerWithRelations, S>;
+        };
+    }>;
+    update<S extends TriggerSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, TriggerPatch> & {
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        updateTrigger: {
+            trigger: InferSelectResult<TriggerWithRelations, S>;
+        };
+    }>;
+    delete<S extends TriggerSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
+        deleteTrigger: {
+            trigger: InferSelectResult<TriggerWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/trigger.js

@@ -0,0 +1,94 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class TriggerModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('Trigger', 'triggers', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'TriggerFilter', 'TriggerOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Trigger',
+            fieldName: 'triggers',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('Trigger', 'triggers', args.select, {
+            where: args?.where,
+        }, 'TriggerFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Trigger',
+            fieldName: 'triggers',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('Trigger', 'triggers', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'TriggerFilter', 'TriggerOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Trigger',
+            fieldName: 'trigger',
+            document,
+            variables,
+            transform: (data) => ({
+                trigger: data.triggers?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('Trigger', 'createTrigger', 'trigger', args.select, args.data, 'CreateTriggerInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Trigger',
+            fieldName: 'createTrigger',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('Trigger', 'updateTrigger', 'trigger', args.select, args.where.id, args.data, 'UpdateTriggerInput', 'id', 'triggerPatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Trigger',
+            fieldName: 'updateTrigger',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('Trigger', 'deleteTrigger', 'trigger', args.where.id, 'DeleteTriggerInput', 'id', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Trigger',
+            fieldName: 'deleteTrigger',
+            document,
+            variables,
+        });
+    }
+}

package/esm/public/orm/models/triggerFunction.d.ts

@@ -0,0 +1,56 @@
+/**
+ * TriggerFunction model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { TriggerFunctionWithRelations, TriggerFunctionSelect, TriggerFunctionFilter, TriggerFunctionOrderBy, CreateTriggerFunctionInput, TriggerFunctionPatch } from '../input-types';
+export declare class TriggerFunctionModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends TriggerFunctionSelect>(args: FindManyArgs<S, TriggerFunctionFilter, TriggerFunctionOrderBy> & {
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        triggerFunctions: ConnectionResult<InferSelectResult<TriggerFunctionWithRelations, S>>;
+    }>;
+    findFirst<S extends TriggerFunctionSelect>(args: FindFirstArgs<S, TriggerFunctionFilter> & {
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        triggerFunctions: {
+            nodes: InferSelectResult<TriggerFunctionWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends TriggerFunctionSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        triggerFunction: InferSelectResult<TriggerFunctionWithRelations, S> | null;
+    }>;
+    create<S extends TriggerFunctionSelect>(args: CreateArgs<S, CreateTriggerFunctionInput['triggerFunction']> & {
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        createTriggerFunction: {
+            triggerFunction: InferSelectResult<TriggerFunctionWithRelations, S>;
+        };
+    }>;
+    update<S extends TriggerFunctionSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, TriggerFunctionPatch> & {
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        updateTriggerFunction: {
+            triggerFunction: InferSelectResult<TriggerFunctionWithRelations, S>;
+        };
+    }>;
+    delete<S extends TriggerFunctionSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
+        deleteTriggerFunction: {
+            triggerFunction: InferSelectResult<TriggerFunctionWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/triggerFunction.js

@@ -0,0 +1,94 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class TriggerFunctionModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('TriggerFunction', 'triggerFunctions', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'TriggerFunctionFilter', 'TriggerFunctionOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TriggerFunction',
+            fieldName: 'triggerFunctions',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('TriggerFunction', 'triggerFunctions', args.select, {
+            where: args?.where,
+        }, 'TriggerFunctionFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TriggerFunction',
+            fieldName: 'triggerFunctions',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('TriggerFunction', 'triggerFunctions', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'TriggerFunctionFilter', 'TriggerFunctionOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'TriggerFunction',
+            fieldName: 'triggerFunction',
+            document,
+            variables,
+            transform: (data) => ({
+                triggerFunction: data.triggerFunctions?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('TriggerFunction', 'createTriggerFunction', 'triggerFunction', args.select, args.data, 'CreateTriggerFunctionInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TriggerFunction',
+            fieldName: 'createTriggerFunction',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('TriggerFunction', 'updateTriggerFunction', 'triggerFunction', args.select, args.where.id, args.data, 'UpdateTriggerFunctionInput', 'id', 'triggerFunctionPatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TriggerFunction',
+            fieldName: 'updateTriggerFunction',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('TriggerFunction', 'deleteTriggerFunction', 'triggerFunction', args.where.id, 'DeleteTriggerFunctionInput', 'id', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'TriggerFunction',
+            fieldName: 'deleteTriggerFunction',
+            document,
+            variables,
+        });
+    }
+}

package/esm/public/orm/models/uniqueConstraint.d.ts

@@ -0,0 +1,56 @@
+/**
+ * UniqueConstraint model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { UniqueConstraintWithRelations, UniqueConstraintSelect, UniqueConstraintFilter, UniqueConstraintOrderBy, CreateUniqueConstraintInput, UniqueConstraintPatch } from '../input-types';
+export declare class UniqueConstraintModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends UniqueConstraintSelect>(args: FindManyArgs<S, UniqueConstraintFilter, UniqueConstraintOrderBy> & {
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        uniqueConstraints: ConnectionResult<InferSelectResult<UniqueConstraintWithRelations, S>>;
+    }>;
+    findFirst<S extends UniqueConstraintSelect>(args: FindFirstArgs<S, UniqueConstraintFilter> & {
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        uniqueConstraints: {
+            nodes: InferSelectResult<UniqueConstraintWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends UniqueConstraintSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        uniqueConstraint: InferSelectResult<UniqueConstraintWithRelations, S> | null;
+    }>;
+    create<S extends UniqueConstraintSelect>(args: CreateArgs<S, CreateUniqueConstraintInput['uniqueConstraint']> & {
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        createUniqueConstraint: {
+            uniqueConstraint: InferSelectResult<UniqueConstraintWithRelations, S>;
+        };
+    }>;
+    update<S extends UniqueConstraintSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, UniqueConstraintPatch> & {
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        updateUniqueConstraint: {
+            uniqueConstraint: InferSelectResult<UniqueConstraintWithRelations, S>;
+        };
+    }>;
+    delete<S extends UniqueConstraintSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
+        deleteUniqueConstraint: {
+            uniqueConstraint: InferSelectResult<UniqueConstraintWithRelations, S>;
+        };
+    }>;
+}