@constructive-io/react 0.21.2 → 0.22.0

package/esm/public/orm/models/{commit.js → computeLogModule.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class CommitModel {
+export class ComputeLogModuleModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('Commit', 'commits', args.select, {
+        const { document, variables } = buildFindManyDocument('ComputeLogModule', 'computeLogModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,85 +14,85 @@ export class CommitModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'CommitFilter', 'CommitOrderBy', connectionFieldsMap);
+        }, 'ComputeLogModuleFilter', 'ComputeLogModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'Commit',
-            fieldName: 'commits',
+            operationName: 'ComputeLogModule',
+            fieldName: 'computeLogModules',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('Commit', 'commits', args.select, {
+        const { document, variables } = buildFindFirstDocument('ComputeLogModule', 'computeLogModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
-        }, 'CommitFilter', 'CommitOrderBy', connectionFieldsMap);
+        }, 'ComputeLogModuleFilter', 'ComputeLogModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'Commit',
-            fieldName: 'commit',
+            operationName: 'ComputeLogModule',
+            fieldName: 'computeLogModule',
             document,
             variables,
             transform: (data) => ({
-                commit: data.commits?.nodes?.[0] ?? null,
+                computeLogModule: data.computeLogModules?.nodes?.[0] ?? null,
             }),
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('Commit', 'commits', args.select, {
+        const { document, variables } = buildFindManyDocument('ComputeLogModule', 'computeLogModules', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'CommitFilter', 'CommitOrderBy', connectionFieldsMap);
+        }, 'ComputeLogModuleFilter', 'ComputeLogModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'Commit',
-            fieldName: 'commit',
+            operationName: 'ComputeLogModule',
+            fieldName: 'computeLogModule',
             document,
             variables,
             transform: (data) => ({
-                commit: data.commits?.nodes?.[0] ?? null,
+                computeLogModule: data.computeLogModules?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('Commit', 'createCommit', 'commit', args.select, args.data, 'CreateCommitInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('ComputeLogModule', 'createComputeLogModule', 'computeLogModule', args.select, args.data, 'CreateComputeLogModuleInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'Commit',
-            fieldName: 'createCommit',
+            operationName: 'ComputeLogModule',
+            fieldName: 'createComputeLogModule',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('Commit', 'updateCommit', 'commit', args.select, args.where.id, args.data, 'UpdateCommitInput', 'id', 'commitPatch', connectionFieldsMap);
+        const { document, variables } = buildUpdateByPkDocument('ComputeLogModule', 'updateComputeLogModule', 'computeLogModule', args.select, args.where.id, args.data, 'UpdateComputeLogModuleInput', 'id', 'computeLogModulePatch', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'Commit',
-            fieldName: 'updateCommit',
+            operationName: 'ComputeLogModule',
+            fieldName: 'updateComputeLogModule',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('Commit', 'deleteCommit', 'commit', {
+        const { document, variables } = buildDeleteByPkDocument('ComputeLogModule', 'deleteComputeLogModule', 'computeLogModule', {
             id: args.where.id,
-        }, 'DeleteCommitInput', args.select, connectionFieldsMap);
+        }, 'DeleteComputeLogModuleInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'Commit',
-            fieldName: 'deleteCommit',
+            operationName: 'ComputeLogModule',
+            fieldName: 'deleteComputeLogModule',
             document,
             variables,
         });

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

@@ -0,0 +1,54 @@
+/**
+ * ConfigSecretsOrgModule 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 { ConfigSecretsOrgModuleWithRelations, ConfigSecretsOrgModuleSelect, ConfigSecretsOrgModuleFilter, ConfigSecretsOrgModuleOrderBy, CreateConfigSecretsOrgModuleInput, ConfigSecretsOrgModulePatch } from '../input-types';
+export declare class ConfigSecretsOrgModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends ConfigSecretsOrgModuleSelect>(args: FindManyArgs<S, ConfigSecretsOrgModuleFilter, ConfigSecretsOrgModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        configSecretsOrgModules: ConnectionResult<InferSelectResult<ConfigSecretsOrgModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends ConfigSecretsOrgModuleSelect>(args: FindFirstArgs<S, ConfigSecretsOrgModuleFilter, ConfigSecretsOrgModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        configSecretsOrgModule: InferSelectResult<ConfigSecretsOrgModuleWithRelations, S> | null;
+    }>;
+    findOne<S extends ConfigSecretsOrgModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        configSecretsOrgModule: InferSelectResult<ConfigSecretsOrgModuleWithRelations, S> | null;
+    }>;
+    create<S extends ConfigSecretsOrgModuleSelect>(args: CreateArgs<S, CreateConfigSecretsOrgModuleInput['configSecretsOrgModule']> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        createConfigSecretsOrgModule: {
+            configSecretsOrgModule: InferSelectResult<ConfigSecretsOrgModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends ConfigSecretsOrgModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, ConfigSecretsOrgModulePatch> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        updateConfigSecretsOrgModule: {
+            configSecretsOrgModule: InferSelectResult<ConfigSecretsOrgModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends ConfigSecretsOrgModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsOrgModuleSelect>): QueryBuilder<{
+        deleteConfigSecretsOrgModule: {
+            configSecretsOrgModule: InferSelectResult<ConfigSecretsOrgModuleWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/{encryptedSecretsModule.js → configSecretsOrgModule.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class EncryptedSecretsModuleModel {
+export class ConfigSecretsOrgModuleModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('EncryptedSecretsModule', 'encryptedSecretsModules', args.select, {
+        const { document, variables } = buildFindManyDocument('ConfigSecretsOrgModule', 'configSecretsOrgModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,85 +14,85 @@ export class EncryptedSecretsModuleModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'EncryptedSecretsModuleFilter', 'EncryptedSecretsModuleOrderBy', connectionFieldsMap);
+        }, 'ConfigSecretsOrgModuleFilter', 'ConfigSecretsOrgModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'encryptedSecretsModules',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'configSecretsOrgModules',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('EncryptedSecretsModule', 'encryptedSecretsModules', args.select, {
+        const { document, variables } = buildFindFirstDocument('ConfigSecretsOrgModule', 'configSecretsOrgModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
-        }, 'EncryptedSecretsModuleFilter', 'EncryptedSecretsModuleOrderBy', connectionFieldsMap);
+        }, 'ConfigSecretsOrgModuleFilter', 'ConfigSecretsOrgModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'encryptedSecretsModule',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'configSecretsOrgModule',
             document,
             variables,
             transform: (data) => ({
-                encryptedSecretsModule: data.encryptedSecretsModules?.nodes?.[0] ?? null,
+                configSecretsOrgModule: data.configSecretsOrgModules?.nodes?.[0] ?? null,
             }),
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('EncryptedSecretsModule', 'encryptedSecretsModules', args.select, {
+        const { document, variables } = buildFindManyDocument('ConfigSecretsOrgModule', 'configSecretsOrgModules', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'EncryptedSecretsModuleFilter', 'EncryptedSecretsModuleOrderBy', connectionFieldsMap);
+        }, 'ConfigSecretsOrgModuleFilter', 'ConfigSecretsOrgModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'encryptedSecretsModule',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'configSecretsOrgModule',
             document,
             variables,
             transform: (data) => ({
-                encryptedSecretsModule: data.encryptedSecretsModules?.nodes?.[0] ?? null,
+                configSecretsOrgModule: data.configSecretsOrgModules?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('EncryptedSecretsModule', 'createEncryptedSecretsModule', 'encryptedSecretsModule', args.select, args.data, 'CreateEncryptedSecretsModuleInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('ConfigSecretsOrgModule', 'createConfigSecretsOrgModule', 'configSecretsOrgModule', args.select, args.data, 'CreateConfigSecretsOrgModuleInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'createEncryptedSecretsModule',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'createConfigSecretsOrgModule',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('EncryptedSecretsModule', 'updateEncryptedSecretsModule', 'encryptedSecretsModule', args.select, args.where.id, args.data, 'UpdateEncryptedSecretsModuleInput', 'id', 'encryptedSecretsModulePatch', connectionFieldsMap);
+        const { document, variables } = buildUpdateByPkDocument('ConfigSecretsOrgModule', 'updateConfigSecretsOrgModule', 'configSecretsOrgModule', args.select, args.where.id, args.data, 'UpdateConfigSecretsOrgModuleInput', 'id', 'configSecretsOrgModulePatch', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'updateEncryptedSecretsModule',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'updateConfigSecretsOrgModule',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('EncryptedSecretsModule', 'deleteEncryptedSecretsModule', 'encryptedSecretsModule', {
+        const { document, variables } = buildDeleteByPkDocument('ConfigSecretsOrgModule', 'deleteConfigSecretsOrgModule', 'configSecretsOrgModule', {
             id: args.where.id,
-        }, 'DeleteEncryptedSecretsModuleInput', args.select, connectionFieldsMap);
+        }, 'DeleteConfigSecretsOrgModuleInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'EncryptedSecretsModule',
-            fieldName: 'deleteEncryptedSecretsModule',
+            operationName: 'ConfigSecretsOrgModule',
+            fieldName: 'deleteConfigSecretsOrgModule',
             document,
             variables,
         });

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

@@ -0,0 +1,54 @@
+/**
+ * ConfigSecretsUserModule 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 { ConfigSecretsUserModuleWithRelations, ConfigSecretsUserModuleSelect, ConfigSecretsUserModuleFilter, ConfigSecretsUserModuleOrderBy, CreateConfigSecretsUserModuleInput, ConfigSecretsUserModulePatch } from '../input-types';
+export declare class ConfigSecretsUserModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends ConfigSecretsUserModuleSelect>(args: FindManyArgs<S, ConfigSecretsUserModuleFilter, ConfigSecretsUserModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        configSecretsUserModules: ConnectionResult<InferSelectResult<ConfigSecretsUserModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends ConfigSecretsUserModuleSelect>(args: FindFirstArgs<S, ConfigSecretsUserModuleFilter, ConfigSecretsUserModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        configSecretsUserModule: InferSelectResult<ConfigSecretsUserModuleWithRelations, S> | null;
+    }>;
+    findOne<S extends ConfigSecretsUserModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        configSecretsUserModule: InferSelectResult<ConfigSecretsUserModuleWithRelations, S> | null;
+    }>;
+    create<S extends ConfigSecretsUserModuleSelect>(args: CreateArgs<S, CreateConfigSecretsUserModuleInput['configSecretsUserModule']> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        createConfigSecretsUserModule: {
+            configSecretsUserModule: InferSelectResult<ConfigSecretsUserModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends ConfigSecretsUserModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, ConfigSecretsUserModulePatch> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        updateConfigSecretsUserModule: {
+            configSecretsUserModule: InferSelectResult<ConfigSecretsUserModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends ConfigSecretsUserModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, ConfigSecretsUserModuleSelect>): QueryBuilder<{
+        deleteConfigSecretsUserModule: {
+            configSecretsUserModule: InferSelectResult<ConfigSecretsUserModuleWithRelations, S>;
+        };
+    }>;
+}

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

@@ -0,0 +1,100 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class ConfigSecretsUserModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('ConfigSecretsUserModule', 'configSecretsUserModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'ConfigSecretsUserModuleFilter', 'ConfigSecretsUserModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'configSecretsUserModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('ConfigSecretsUserModule', 'configSecretsUserModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+        }, 'ConfigSecretsUserModuleFilter', 'ConfigSecretsUserModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'configSecretsUserModule',
+            document,
+            variables,
+            transform: (data) => ({
+                configSecretsUserModule: data.configSecretsUserModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('ConfigSecretsUserModule', 'configSecretsUserModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'ConfigSecretsUserModuleFilter', 'ConfigSecretsUserModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'configSecretsUserModule',
+            document,
+            variables,
+            transform: (data) => ({
+                configSecretsUserModule: data.configSecretsUserModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('ConfigSecretsUserModule', 'createConfigSecretsUserModule', 'configSecretsUserModule', args.select, args.data, 'CreateConfigSecretsUserModuleInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'createConfigSecretsUserModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('ConfigSecretsUserModule', 'updateConfigSecretsUserModule', 'configSecretsUserModule', args.select, args.where.id, args.data, 'UpdateConfigSecretsUserModuleInput', 'id', 'configSecretsUserModulePatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'updateConfigSecretsUserModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('ConfigSecretsUserModule', 'deleteConfigSecretsUserModule', 'configSecretsUserModule', {
+            id: args.where.id,
+        }, 'DeleteConfigSecretsUserModuleInput', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ConfigSecretsUserModule',
+            fieldName: 'deleteConfigSecretsUserModule',
+            document,
+            variables,
+        });
+    }
+}

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

@@ -0,0 +1,54 @@
+/**
+ * DbUsageModule 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 { DbUsageModuleWithRelations, DbUsageModuleSelect, DbUsageModuleFilter, DbUsageModuleOrderBy, CreateDbUsageModuleInput, DbUsageModulePatch } from '../input-types';
+export declare class DbUsageModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends DbUsageModuleSelect>(args: FindManyArgs<S, DbUsageModuleFilter, DbUsageModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        dbUsageModules: ConnectionResult<InferSelectResult<DbUsageModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends DbUsageModuleSelect>(args: FindFirstArgs<S, DbUsageModuleFilter, DbUsageModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        dbUsageModule: InferSelectResult<DbUsageModuleWithRelations, S> | null;
+    }>;
+    findOne<S extends DbUsageModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        dbUsageModule: InferSelectResult<DbUsageModuleWithRelations, S> | null;
+    }>;
+    create<S extends DbUsageModuleSelect>(args: CreateArgs<S, CreateDbUsageModuleInput['dbUsageModule']> & {
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        createDbUsageModule: {
+            dbUsageModule: InferSelectResult<DbUsageModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends DbUsageModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, DbUsageModulePatch> & {
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        updateDbUsageModule: {
+            dbUsageModule: InferSelectResult<DbUsageModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends DbUsageModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, DbUsageModuleSelect>): QueryBuilder<{
+        deleteDbUsageModule: {
+            dbUsageModule: InferSelectResult<DbUsageModuleWithRelations, S>;
+        };
+    }>;
+}

package/esm/public/orm/models/{usageSnapshot.js → dbUsageModule.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class UsageSnapshotModel {
+export class DbUsageModuleModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('UsageSnapshot', 'usageSnapshots', args.select, {
+        const { document, variables } = buildFindManyDocument('DbUsageModule', 'dbUsageModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,85 +14,85 @@ export class UsageSnapshotModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'UsageSnapshotFilter', 'UsageSnapshotOrderBy', connectionFieldsMap);
+        }, 'DbUsageModuleFilter', 'DbUsageModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'UsageSnapshot',
-            fieldName: 'usageSnapshots',
+            operationName: 'DbUsageModule',
+            fieldName: 'dbUsageModules',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('UsageSnapshot', 'usageSnapshots', args.select, {
+        const { document, variables } = buildFindFirstDocument('DbUsageModule', 'dbUsageModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
-        }, 'UsageSnapshotFilter', 'UsageSnapshotOrderBy', connectionFieldsMap);
+        }, 'DbUsageModuleFilter', 'DbUsageModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'UsageSnapshot',
-            fieldName: 'usageSnapshot',
+            operationName: 'DbUsageModule',
+            fieldName: 'dbUsageModule',
             document,
             variables,
             transform: (data) => ({
-                usageSnapshot: data.usageSnapshots?.nodes?.[0] ?? null,
+                dbUsageModule: data.dbUsageModules?.nodes?.[0] ?? null,
             }),
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('UsageSnapshot', 'usageSnapshots', args.select, {
+        const { document, variables } = buildFindManyDocument('DbUsageModule', 'dbUsageModules', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'UsageSnapshotFilter', 'UsageSnapshotOrderBy', connectionFieldsMap);
+        }, 'DbUsageModuleFilter', 'DbUsageModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'UsageSnapshot',
-            fieldName: 'usageSnapshot',
+            operationName: 'DbUsageModule',
+            fieldName: 'dbUsageModule',
             document,
             variables,
             transform: (data) => ({
-                usageSnapshot: data.usageSnapshots?.nodes?.[0] ?? null,
+                dbUsageModule: data.dbUsageModules?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('UsageSnapshot', 'createUsageSnapshot', 'usageSnapshot', args.select, args.data, 'CreateUsageSnapshotInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('DbUsageModule', 'createDbUsageModule', 'dbUsageModule', args.select, args.data, 'CreateDbUsageModuleInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'UsageSnapshot',
-            fieldName: 'createUsageSnapshot',
+            operationName: 'DbUsageModule',
+            fieldName: 'createDbUsageModule',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('UsageSnapshot', 'updateUsageSnapshot', 'usageSnapshot', args.select, args.where.id, args.data, 'UpdateUsageSnapshotInput', 'id', 'usageSnapshotPatch', connectionFieldsMap);
+        const { document, variables } = buildUpdateByPkDocument('DbUsageModule', 'updateDbUsageModule', 'dbUsageModule', args.select, args.where.id, args.data, 'UpdateDbUsageModuleInput', 'id', 'dbUsageModulePatch', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'UsageSnapshot',
-            fieldName: 'updateUsageSnapshot',
+            operationName: 'DbUsageModule',
+            fieldName: 'updateDbUsageModule',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('UsageSnapshot', 'deleteUsageSnapshot', 'usageSnapshot', {
+        const { document, variables } = buildDeleteByPkDocument('DbUsageModule', 'deleteDbUsageModule', 'dbUsageModule', {
             id: args.where.id,
-        }, 'DeleteUsageSnapshotInput', args.select, connectionFieldsMap);
+        }, 'DeleteDbUsageModuleInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'UsageSnapshot',
-            fieldName: 'deleteUsageSnapshot',
+            operationName: 'DbUsageModule',
+            fieldName: 'deleteDbUsageModule',
             document,
             variables,
         });