@constructive-io/sdk 0.0.2

package/public/orm/models/invitesModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * InvitesModule 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 { InvitesModuleWithRelations, InvitesModuleSelect, InvitesModuleFilter, InvitesModuleOrderBy, CreateInvitesModuleInput, InvitesModulePatch } from '../input-types';
+export declare class InvitesModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends InvitesModuleSelect>(args: FindManyArgs<S, InvitesModuleFilter, InvitesModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        invitesModules: ConnectionResult<InferSelectResult<InvitesModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        invitesModules: {
+            nodes: InferSelectResult<InvitesModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends InvitesModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        invitesModule: InferSelectResult<InvitesModuleWithRelations, S> | null;
+    }>;
+    create<S extends InvitesModuleSelect>(args: CreateArgs<S, CreateInvitesModuleInput['invitesModule']> & {
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        createInvitesModule: {
+            invitesModule: InferSelectResult<InvitesModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends InvitesModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, InvitesModulePatch> & {
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        updateInvitesModule: {
+            invitesModule: InferSelectResult<InvitesModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends InvitesModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
+        deleteInvitesModule: {
+            invitesModule: InferSelectResult<InvitesModuleWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/invitesModule.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitesModuleModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class InvitesModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('InvitesModule', 'invitesModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'InvitesModuleFilter', 'InvitesModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'InvitesModule',
+            fieldName: 'invitesModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('InvitesModule', 'invitesModules', args.select, {
+            where: args?.where,
+        }, 'InvitesModuleFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'InvitesModule',
+            fieldName: 'invitesModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('InvitesModule', 'invitesModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'InvitesModuleFilter', 'InvitesModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'InvitesModule',
+            fieldName: 'invitesModule',
+            document,
+            variables,
+            transform: (data) => ({
+                invitesModule: data.invitesModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('InvitesModule', 'createInvitesModule', 'invitesModule', args.select, args.data, 'CreateInvitesModuleInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'InvitesModule',
+            fieldName: 'createInvitesModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('InvitesModule', 'updateInvitesModule', 'invitesModule', args.select, args.where.id, args.data, 'UpdateInvitesModuleInput', 'id', 'invitesModulePatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'InvitesModule',
+            fieldName: 'updateInvitesModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('InvitesModule', 'deleteInvitesModule', 'invitesModule', args.where.id, 'DeleteInvitesModuleInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'InvitesModule',
+            fieldName: 'deleteInvitesModule',
+            document,
+            variables,
+        });
+    }
+}
+exports.InvitesModuleModel = InvitesModuleModel;

package/public/orm/models/levelsModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * LevelsModule 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 { LevelsModuleWithRelations, LevelsModuleSelect, LevelsModuleFilter, LevelsModuleOrderBy, CreateLevelsModuleInput, LevelsModulePatch } from '../input-types';
+export declare class LevelsModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends LevelsModuleSelect>(args: FindManyArgs<S, LevelsModuleFilter, LevelsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        levelsModules: ConnectionResult<InferSelectResult<LevelsModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends LevelsModuleSelect>(args: FindFirstArgs<S, LevelsModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        levelsModules: {
+            nodes: InferSelectResult<LevelsModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends LevelsModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        levelsModule: InferSelectResult<LevelsModuleWithRelations, S> | null;
+    }>;
+    create<S extends LevelsModuleSelect>(args: CreateArgs<S, CreateLevelsModuleInput['levelsModule']> & {
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        createLevelsModule: {
+            levelsModule: InferSelectResult<LevelsModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends LevelsModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, LevelsModulePatch> & {
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        updateLevelsModule: {
+            levelsModule: InferSelectResult<LevelsModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends LevelsModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
+        deleteLevelsModule: {
+            levelsModule: InferSelectResult<LevelsModuleWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/levelsModule.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LevelsModuleModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class LevelsModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LevelsModule', 'levelsModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'LevelsModuleFilter', 'LevelsModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LevelsModule',
+            fieldName: 'levelsModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('LevelsModule', 'levelsModules', args.select, {
+            where: args?.where,
+        }, 'LevelsModuleFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LevelsModule',
+            fieldName: 'levelsModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LevelsModule', 'levelsModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'LevelsModuleFilter', 'LevelsModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LevelsModule',
+            fieldName: 'levelsModule',
+            document,
+            variables,
+            transform: (data) => ({
+                levelsModule: data.levelsModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('LevelsModule', 'createLevelsModule', 'levelsModule', args.select, args.data, 'CreateLevelsModuleInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LevelsModule',
+            fieldName: 'createLevelsModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('LevelsModule', 'updateLevelsModule', 'levelsModule', args.select, args.where.id, args.data, 'UpdateLevelsModuleInput', 'id', 'levelsModulePatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LevelsModule',
+            fieldName: 'updateLevelsModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('LevelsModule', 'deleteLevelsModule', 'levelsModule', args.where.id, 'DeleteLevelsModuleInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LevelsModule',
+            fieldName: 'deleteLevelsModule',
+            document,
+            variables,
+        });
+    }
+}
+exports.LevelsModuleModel = LevelsModuleModel;

package/public/orm/models/limitFunction.d.ts

@@ -0,0 +1,56 @@
+/**
+ * LimitFunction 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 { LimitFunctionWithRelations, LimitFunctionSelect, LimitFunctionFilter, LimitFunctionOrderBy, CreateLimitFunctionInput, LimitFunctionPatch } from '../input-types';
+export declare class LimitFunctionModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends LimitFunctionSelect>(args: FindManyArgs<S, LimitFunctionFilter, LimitFunctionOrderBy> & {
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        limitFunctions: ConnectionResult<InferSelectResult<LimitFunctionWithRelations, S>>;
+    }>;
+    findFirst<S extends LimitFunctionSelect>(args: FindFirstArgs<S, LimitFunctionFilter> & {
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        limitFunctions: {
+            nodes: InferSelectResult<LimitFunctionWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends LimitFunctionSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        limitFunction: InferSelectResult<LimitFunctionWithRelations, S> | null;
+    }>;
+    create<S extends LimitFunctionSelect>(args: CreateArgs<S, CreateLimitFunctionInput['limitFunction']> & {
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        createLimitFunction: {
+            limitFunction: InferSelectResult<LimitFunctionWithRelations, S>;
+        };
+    }>;
+    update<S extends LimitFunctionSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, LimitFunctionPatch> & {
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        updateLimitFunction: {
+            limitFunction: InferSelectResult<LimitFunctionWithRelations, S>;
+        };
+    }>;
+    delete<S extends LimitFunctionSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, LimitFunctionSelect>): QueryBuilder<{
+        deleteLimitFunction: {
+            limitFunction: InferSelectResult<LimitFunctionWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/limitFunction.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitFunctionModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class LimitFunctionModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LimitFunction', 'limitFunctions', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'LimitFunctionFilter', 'LimitFunctionOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitFunction',
+            fieldName: 'limitFunctions',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('LimitFunction', 'limitFunctions', args.select, {
+            where: args?.where,
+        }, 'LimitFunctionFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitFunction',
+            fieldName: 'limitFunctions',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LimitFunction', 'limitFunctions', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'LimitFunctionFilter', 'LimitFunctionOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitFunction',
+            fieldName: 'limitFunction',
+            document,
+            variables,
+            transform: (data) => ({
+                limitFunction: data.limitFunctions?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('LimitFunction', 'createLimitFunction', 'limitFunction', args.select, args.data, 'CreateLimitFunctionInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitFunction',
+            fieldName: 'createLimitFunction',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('LimitFunction', 'updateLimitFunction', 'limitFunction', args.select, args.where.id, args.data, 'UpdateLimitFunctionInput', 'id', 'limitFunctionPatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitFunction',
+            fieldName: 'updateLimitFunction',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('LimitFunction', 'deleteLimitFunction', 'limitFunction', args.where.id, 'DeleteLimitFunctionInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitFunction',
+            fieldName: 'deleteLimitFunction',
+            document,
+            variables,
+        });
+    }
+}
+exports.LimitFunctionModel = LimitFunctionModel;

package/public/orm/models/limitsModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * LimitsModule 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 { LimitsModuleWithRelations, LimitsModuleSelect, LimitsModuleFilter, LimitsModuleOrderBy, CreateLimitsModuleInput, LimitsModulePatch } from '../input-types';
+export declare class LimitsModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends LimitsModuleSelect>(args: FindManyArgs<S, LimitsModuleFilter, LimitsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        limitsModules: ConnectionResult<InferSelectResult<LimitsModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends LimitsModuleSelect>(args: FindFirstArgs<S, LimitsModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        limitsModules: {
+            nodes: InferSelectResult<LimitsModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends LimitsModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        limitsModule: InferSelectResult<LimitsModuleWithRelations, S> | null;
+    }>;
+    create<S extends LimitsModuleSelect>(args: CreateArgs<S, CreateLimitsModuleInput['limitsModule']> & {
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        createLimitsModule: {
+            limitsModule: InferSelectResult<LimitsModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends LimitsModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, LimitsModulePatch> & {
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        updateLimitsModule: {
+            limitsModule: InferSelectResult<LimitsModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends LimitsModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
+        deleteLimitsModule: {
+            limitsModule: InferSelectResult<LimitsModuleWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/limitsModule.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitsModuleModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class LimitsModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LimitsModule', 'limitsModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'LimitsModuleFilter', 'LimitsModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitsModule',
+            fieldName: 'limitsModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('LimitsModule', 'limitsModules', args.select, {
+            where: args?.where,
+        }, 'LimitsModuleFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitsModule',
+            fieldName: 'limitsModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('LimitsModule', 'limitsModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'LimitsModuleFilter', 'LimitsModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'LimitsModule',
+            fieldName: 'limitsModule',
+            document,
+            variables,
+            transform: (data) => ({
+                limitsModule: data.limitsModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('LimitsModule', 'createLimitsModule', 'limitsModule', args.select, args.data, 'CreateLimitsModuleInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitsModule',
+            fieldName: 'createLimitsModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('LimitsModule', 'updateLimitsModule', 'limitsModule', args.select, args.where.id, args.data, 'UpdateLimitsModuleInput', 'id', 'limitsModulePatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitsModule',
+            fieldName: 'updateLimitsModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('LimitsModule', 'deleteLimitsModule', 'limitsModule', args.where.id, 'DeleteLimitsModuleInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'LimitsModule',
+            fieldName: 'deleteLimitsModule',
+            document,
+            variables,
+        });
+    }
+}
+exports.LimitsModuleModel = LimitsModuleModel;

package/public/orm/models/membershipType.d.ts

@@ -0,0 +1,56 @@
+/**
+ * MembershipType 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 { MembershipTypeWithRelations, MembershipTypeSelect, MembershipTypeFilter, MembershipTypeOrderBy, CreateMembershipTypeInput, MembershipTypePatch } from '../input-types';
+export declare class MembershipTypeModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends MembershipTypeSelect>(args: FindManyArgs<S, MembershipTypeFilter, MembershipTypeOrderBy> & {
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        membershipTypes: ConnectionResult<InferSelectResult<MembershipTypeWithRelations, S>>;
+    }>;
+    findFirst<S extends MembershipTypeSelect>(args: FindFirstArgs<S, MembershipTypeFilter> & {
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        membershipTypes: {
+            nodes: InferSelectResult<MembershipTypeWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends MembershipTypeSelect>(args: {
+        id: number;
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        membershipType: InferSelectResult<MembershipTypeWithRelations, S> | null;
+    }>;
+    create<S extends MembershipTypeSelect>(args: CreateArgs<S, CreateMembershipTypeInput['membershipType']> & {
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        createMembershipType: {
+            membershipType: InferSelectResult<MembershipTypeWithRelations, S>;
+        };
+    }>;
+    update<S extends MembershipTypeSelect>(args: UpdateArgs<S, {
+        id: number;
+    }, MembershipTypePatch> & {
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        updateMembershipType: {
+            membershipType: InferSelectResult<MembershipTypeWithRelations, S>;
+        };
+    }>;
+    delete<S extends MembershipTypeSelect>(args: DeleteArgs<{
+        id: number;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
+        deleteMembershipType: {
+            membershipType: InferSelectResult<MembershipTypeWithRelations, S>;
+        };
+    }>;
+}