@constructive-sdk/cli 0.21.6 → 0.21.8

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

@@ -15,12 +15,10 @@ export declare class CryptoAddressesModuleModel {
     } & StrictSelect<S, CryptoAddressesModuleSelect>): QueryBuilder<{
         cryptoAddressesModules: ConnectionResult<InferSelectResult<CryptoAddressesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAddressesModuleSelect>(args: FindFirstArgs<S, CryptoAddressesModuleFilter> & {
+    findFirst<S extends CryptoAddressesModuleSelect>(args: FindFirstArgs<S, CryptoAddressesModuleFilter, CryptoAddressesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAddressesModuleSelect>): QueryBuilder<{
-        cryptoAddressesModules: {
-            nodes: InferSelectResult<CryptoAddressesModuleWithRelations, S>[];
-        };
+        cryptoAddressesModule: InferSelectResult<CryptoAddressesModuleWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAddressesModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAddressesModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAddressesModule', 'cryptoAddressesModules', args.select, {
             where: args?.where,
-        }, 'CryptoAddressesModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAddressesModuleFilter', 'CryptoAddressesModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAddressesModule',
-            fieldName: 'cryptoAddressesModules',
+            fieldName: 'cryptoAddressesModule',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAddressesModule: data.cryptoAddressesModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAuthModuleModel {
     } & StrictSelect<S, CryptoAuthModuleSelect>): QueryBuilder<{
         cryptoAuthModules: ConnectionResult<InferSelectResult<CryptoAuthModuleWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAuthModuleSelect>(args: FindFirstArgs<S, CryptoAuthModuleFilter> & {
+    findFirst<S extends CryptoAuthModuleSelect>(args: FindFirstArgs<S, CryptoAuthModuleFilter, CryptoAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAuthModuleSelect>): QueryBuilder<{
-        cryptoAuthModules: {
-            nodes: InferSelectResult<CryptoAuthModuleWithRelations, S>[];
-        };
+        cryptoAuthModule: InferSelectResult<CryptoAuthModuleWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAuthModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class CryptoAuthModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('CryptoAuthModule', 'cryptoAuthModules', args.select, {
             where: args?.where,
-        }, 'CryptoAuthModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAuthModuleFilter', 'CryptoAuthModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAuthModule',
-            fieldName: 'cryptoAuthModules',
+            fieldName: 'cryptoAuthModule',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAuthModule: data.cryptoAuthModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseModel {
     } & StrictSelect<S, DatabaseSelect>): QueryBuilder<{
         databases: ConnectionResult<InferSelectResult<DatabaseWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseSelect>(args: FindFirstArgs<S, DatabaseFilter> & {
+    findFirst<S extends DatabaseSelect>(args: FindFirstArgs<S, DatabaseFilter, DatabaseOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseSelect>): QueryBuilder<{
-        databases: {
-            nodes: InferSelectResult<DatabaseWithRelations, S>[];
-        };
+        database: InferSelectResult<DatabaseWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Database', 'databases', args.select, {
             where: args?.where,
-        }, 'DatabaseFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseFilter', 'DatabaseOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Database',
-            fieldName: 'databases',
+            fieldName: 'database',
             document,
             variables,
+            transform: (data) => ({
+                database: data.databases?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseProvisionModuleModel {
     } & StrictSelect<S, DatabaseProvisionModuleSelect>): QueryBuilder<{
         databaseProvisionModules: ConnectionResult<InferSelectResult<DatabaseProvisionModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseProvisionModuleSelect>(args: FindFirstArgs<S, DatabaseProvisionModuleFilter> & {
+    findFirst<S extends DatabaseProvisionModuleSelect>(args: FindFirstArgs<S, DatabaseProvisionModuleFilter, DatabaseProvisionModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseProvisionModuleSelect>): QueryBuilder<{
-        databaseProvisionModules: {
-            nodes: InferSelectResult<DatabaseProvisionModuleWithRelations, S>[];
-        };
+        databaseProvisionModule: InferSelectResult<DatabaseProvisionModuleWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseProvisionModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseProvisionModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseProvisionModule', 'databaseProvisionModules', args.select, {
             where: args?.where,
-        }, 'DatabaseProvisionModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseProvisionModuleFilter', 'DatabaseProvisionModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseProvisionModule',
-            fieldName: 'databaseProvisionModules',
+            fieldName: 'databaseProvisionModule',
             document,
             variables,
+            transform: (data) => ({
+                databaseProvisionModule: data.databaseProvisionModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseSettingModel {
     } & StrictSelect<S, DatabaseSettingSelect>): QueryBuilder<{
         databaseSettings: ConnectionResult<InferSelectResult<DatabaseSettingWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseSettingSelect>(args: FindFirstArgs<S, DatabaseSettingFilter> & {
+    findFirst<S extends DatabaseSettingSelect>(args: FindFirstArgs<S, DatabaseSettingFilter, DatabaseSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseSettingSelect>): QueryBuilder<{
-        databaseSettings: {
-            nodes: InferSelectResult<DatabaseSettingWithRelations, S>[];
-        };
+        databaseSetting: InferSelectResult<DatabaseSettingWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseSettingSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseSetting', 'databaseSettings', args.select, {
             where: args?.where,
-        }, 'DatabaseSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseSettingFilter', 'DatabaseSettingOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseSetting',
-            fieldName: 'databaseSettings',
+            fieldName: 'databaseSetting',
             document,
             variables,
+            transform: (data) => ({
+                databaseSetting: data.databaseSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DatabaseTransferModel {
     } & StrictSelect<S, DatabaseTransferSelect>): QueryBuilder<{
         databaseTransfers: ConnectionResult<InferSelectResult<DatabaseTransferWithRelations, S>>;
     }>;
-    findFirst<S extends DatabaseTransferSelect>(args: FindFirstArgs<S, DatabaseTransferFilter> & {
+    findFirst<S extends DatabaseTransferSelect>(args: FindFirstArgs<S, DatabaseTransferFilter, DatabaseTransferOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseTransferSelect>): QueryBuilder<{
-        databaseTransfers: {
-            nodes: InferSelectResult<DatabaseTransferWithRelations, S>[];
-        };
+        databaseTransfer: InferSelectResult<DatabaseTransferWithRelations, S> | null;
     }>;
     findOne<S extends DatabaseTransferSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DatabaseTransferModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DatabaseTransfer', 'databaseTransfers', args.select, {
             where: args?.where,
-        }, 'DatabaseTransferFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DatabaseTransferFilter', 'DatabaseTransferOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DatabaseTransfer',
-            fieldName: 'databaseTransfers',
+            fieldName: 'databaseTransfer',
             document,
             variables,
+            transform: (data) => ({
+                databaseTransfer: data.databaseTransfers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DefaultIdsModuleModel {
     } & StrictSelect<S, DefaultIdsModuleSelect>): QueryBuilder<{
         defaultIdsModules: ConnectionResult<InferSelectResult<DefaultIdsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DefaultIdsModuleSelect>(args: FindFirstArgs<S, DefaultIdsModuleFilter> & {
+    findFirst<S extends DefaultIdsModuleSelect>(args: FindFirstArgs<S, DefaultIdsModuleFilter, DefaultIdsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultIdsModuleSelect>): QueryBuilder<{
-        defaultIdsModules: {
-            nodes: InferSelectResult<DefaultIdsModuleWithRelations, S>[];
-        };
+        defaultIdsModule: InferSelectResult<DefaultIdsModuleWithRelations, S> | null;
     }>;
     findOne<S extends DefaultIdsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DefaultIdsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DefaultIdsModule', 'defaultIdsModules', args.select, {
             where: args?.where,
-        }, 'DefaultIdsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DefaultIdsModuleFilter', 'DefaultIdsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DefaultIdsModule',
-            fieldName: 'defaultIdsModules',
+            fieldName: 'defaultIdsModule',
             document,
             variables,
+            transform: (data) => ({
+                defaultIdsModule: data.defaultIdsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DefaultPrivilegeModel {
     } & StrictSelect<S, DefaultPrivilegeSelect>): QueryBuilder<{
         defaultPrivileges: ConnectionResult<InferSelectResult<DefaultPrivilegeWithRelations, S>>;
     }>;
-    findFirst<S extends DefaultPrivilegeSelect>(args: FindFirstArgs<S, DefaultPrivilegeFilter> & {
+    findFirst<S extends DefaultPrivilegeSelect>(args: FindFirstArgs<S, DefaultPrivilegeFilter, DefaultPrivilegeOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultPrivilegeSelect>): QueryBuilder<{
-        defaultPrivileges: {
-            nodes: InferSelectResult<DefaultPrivilegeWithRelations, S>[];
-        };
+        defaultPrivilege: InferSelectResult<DefaultPrivilegeWithRelations, S> | null;
     }>;
     findOne<S extends DefaultPrivilegeSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DefaultPrivilegeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DefaultPrivilege', 'defaultPrivileges', args.select, {
             where: args?.where,
-        }, 'DefaultPrivilegeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DefaultPrivilegeFilter', 'DefaultPrivilegeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DefaultPrivilege',
-            fieldName: 'defaultPrivileges',
+            fieldName: 'defaultPrivilege',
             document,
             variables,
+            transform: (data) => ({
+                defaultPrivilege: data.defaultPrivileges?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DenormalizedTableFieldModel {
     } & StrictSelect<S, DenormalizedTableFieldSelect>): QueryBuilder<{
         denormalizedTableFields: ConnectionResult<InferSelectResult<DenormalizedTableFieldWithRelations, S>>;
     }>;
-    findFirst<S extends DenormalizedTableFieldSelect>(args: FindFirstArgs<S, DenormalizedTableFieldFilter> & {
+    findFirst<S extends DenormalizedTableFieldSelect>(args: FindFirstArgs<S, DenormalizedTableFieldFilter, DenormalizedTableFieldOrderBy> & {
         select: S;
     } & StrictSelect<S, DenormalizedTableFieldSelect>): QueryBuilder<{
-        denormalizedTableFields: {
-            nodes: InferSelectResult<DenormalizedTableFieldWithRelations, S>[];
-        };
+        denormalizedTableField: InferSelectResult<DenormalizedTableFieldWithRelations, S> | null;
     }>;
     findOne<S extends DenormalizedTableFieldSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DenormalizedTableFieldModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DenormalizedTableField', 'denormalizedTableFields', args.select, {
             where: args?.where,
-        }, 'DenormalizedTableFieldFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DenormalizedTableFieldFilter', 'DenormalizedTableFieldOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DenormalizedTableField',
-            fieldName: 'denormalizedTableFields',
+            fieldName: 'denormalizedTableField',
             document,
             variables,
+            transform: (data) => ({
+                denormalizedTableField: data.denormalizedTableFields?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DevicesModuleModel {
     } & StrictSelect<S, DevicesModuleSelect>): QueryBuilder<{
         devicesModules: ConnectionResult<InferSelectResult<DevicesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends DevicesModuleSelect>(args: FindFirstArgs<S, DevicesModuleFilter> & {
+    findFirst<S extends DevicesModuleSelect>(args: FindFirstArgs<S, DevicesModuleFilter, DevicesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DevicesModuleSelect>): QueryBuilder<{
-        devicesModules: {
-            nodes: InferSelectResult<DevicesModuleWithRelations, S>[];
-        };
+        devicesModule: InferSelectResult<DevicesModuleWithRelations, S> | null;
     }>;
     findOne<S extends DevicesModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DevicesModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('DevicesModule', 'devicesModules', args.select, {
             where: args?.where,
-        }, 'DevicesModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DevicesModuleFilter', 'DevicesModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'DevicesModule',
-            fieldName: 'devicesModules',
+            fieldName: 'devicesModule',
             document,
             variables,
+            transform: (data) => ({
+                devicesModule: data.devicesModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class DomainModel {
     } & StrictSelect<S, DomainSelect>): QueryBuilder<{
         domains: ConnectionResult<InferSelectResult<DomainWithRelations, S>>;
     }>;
-    findFirst<S extends DomainSelect>(args: FindFirstArgs<S, DomainFilter> & {
+    findFirst<S extends DomainSelect>(args: FindFirstArgs<S, DomainFilter, DomainOrderBy> & {
         select: S;
     } & StrictSelect<S, DomainSelect>): QueryBuilder<{
-        domains: {
-            nodes: InferSelectResult<DomainWithRelations, S>[];
-        };
+        domain: InferSelectResult<DomainWithRelations, S> | null;
     }>;
     findOne<S extends DomainSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class DomainModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Domain', 'domains', args.select, {
             where: args?.where,
-        }, 'DomainFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'DomainFilter', 'DomainOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Domain',
-            fieldName: 'domains',
+            fieldName: 'domain',
             document,
             variables,
+            transform: (data) => ({
+                domain: data.domains?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EmailModel {
     } & StrictSelect<S, EmailSelect>): QueryBuilder<{
         emails: ConnectionResult<InferSelectResult<EmailWithRelations, S>>;
     }>;
-    findFirst<S extends EmailSelect>(args: FindFirstArgs<S, EmailFilter> & {
+    findFirst<S extends EmailSelect>(args: FindFirstArgs<S, EmailFilter, EmailOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailSelect>): QueryBuilder<{
-        emails: {
-            nodes: InferSelectResult<EmailWithRelations, S>[];
-        };
+        email: InferSelectResult<EmailWithRelations, S> | null;
     }>;
     findOne<S extends EmailSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class EmailModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Email', 'emails', args.select, {
             where: args?.where,
-        }, 'EmailFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmailFilter', 'EmailOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Email',
-            fieldName: 'emails',
+            fieldName: 'email',
             document,
             variables,
+            transform: (data) => ({
+                email: data.emails?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EmailsModuleModel {
     } & StrictSelect<S, EmailsModuleSelect>): QueryBuilder<{
         emailsModules: ConnectionResult<InferSelectResult<EmailsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends EmailsModuleSelect>(args: FindFirstArgs<S, EmailsModuleFilter> & {
+    findFirst<S extends EmailsModuleSelect>(args: FindFirstArgs<S, EmailsModuleFilter, EmailsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailsModuleSelect>): QueryBuilder<{
-        emailsModules: {
-            nodes: InferSelectResult<EmailsModuleWithRelations, S>[];
-        };
+        emailsModule: InferSelectResult<EmailsModuleWithRelations, S> | null;
     }>;
     findOne<S extends EmailsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class EmailsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EmailsModule', 'emailsModules', args.select, {
             where: args?.where,
-        }, 'EmailsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmailsModuleFilter', 'EmailsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EmailsModule',
-            fieldName: 'emailsModules',
+            fieldName: 'emailsModule',
             document,
             variables,
+            transform: (data) => ({
+                emailsModule: data.emailsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EmbeddingChunkModel {
     } & StrictSelect<S, EmbeddingChunkSelect>): QueryBuilder<{
         embeddingChunks: ConnectionResult<InferSelectResult<EmbeddingChunkWithRelations, S>>;
     }>;
-    findFirst<S extends EmbeddingChunkSelect>(args: FindFirstArgs<S, EmbeddingChunkFilter> & {
+    findFirst<S extends EmbeddingChunkSelect>(args: FindFirstArgs<S, EmbeddingChunkFilter, EmbeddingChunkOrderBy> & {
         select: S;
     } & StrictSelect<S, EmbeddingChunkSelect>): QueryBuilder<{
-        embeddingChunks: {
-            nodes: InferSelectResult<EmbeddingChunkWithRelations, S>[];
-        };
+        embeddingChunk: InferSelectResult<EmbeddingChunkWithRelations, S> | null;
     }>;
     findOne<S extends EmbeddingChunkSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class EmbeddingChunkModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EmbeddingChunk', 'embeddingChunks', args.select, {
             where: args?.where,
-        }, 'EmbeddingChunkFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EmbeddingChunkFilter', 'EmbeddingChunkOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EmbeddingChunk',
-            fieldName: 'embeddingChunks',
+            fieldName: 'embeddingChunk',
             document,
             variables,
+            transform: (data) => ({
+                embeddingChunk: data.embeddingChunks?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EncryptedSecretsModuleModel {
     } & StrictSelect<S, EncryptedSecretsModuleSelect>): QueryBuilder<{
         encryptedSecretsModules: ConnectionResult<InferSelectResult<EncryptedSecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends EncryptedSecretsModuleSelect>(args: FindFirstArgs<S, EncryptedSecretsModuleFilter> & {
+    findFirst<S extends EncryptedSecretsModuleSelect>(args: FindFirstArgs<S, EncryptedSecretsModuleFilter, EncryptedSecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EncryptedSecretsModuleSelect>): QueryBuilder<{
-        encryptedSecretsModules: {
-            nodes: InferSelectResult<EncryptedSecretsModuleWithRelations, S>[];
-        };
+        encryptedSecretsModule: InferSelectResult<EncryptedSecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends EncryptedSecretsModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class EncryptedSecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EncryptedSecretsModule', 'encryptedSecretsModules', args.select, {
             where: args?.where,
-        }, 'EncryptedSecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EncryptedSecretsModuleFilter', 'EncryptedSecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EncryptedSecretsModule',
-            fieldName: 'encryptedSecretsModules',
+            fieldName: 'encryptedSecretsModule',
             document,
             variables,
+            transform: (data) => ({
+                encryptedSecretsModule: data.encryptedSecretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EntityTypeProvisionModel {
     } & StrictSelect<S, EntityTypeProvisionSelect>): QueryBuilder<{
         entityTypeProvisions: ConnectionResult<InferSelectResult<EntityTypeProvisionWithRelations, S>>;
     }>;
-    findFirst<S extends EntityTypeProvisionSelect>(args: FindFirstArgs<S, EntityTypeProvisionFilter> & {
+    findFirst<S extends EntityTypeProvisionSelect>(args: FindFirstArgs<S, EntityTypeProvisionFilter, EntityTypeProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, EntityTypeProvisionSelect>): QueryBuilder<{
-        entityTypeProvisions: {
-            nodes: InferSelectResult<EntityTypeProvisionWithRelations, S>[];
-        };
+        entityTypeProvision: InferSelectResult<EntityTypeProvisionWithRelations, S> | null;
     }>;
     findOne<S extends EntityTypeProvisionSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class EntityTypeProvisionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('EntityTypeProvision', 'entityTypeProvisions', args.select, {
             where: args?.where,
-        }, 'EntityTypeProvisionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'EntityTypeProvisionFilter', 'EntityTypeProvisionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'EntityTypeProvision',
-            fieldName: 'entityTypeProvisions',
+            fieldName: 'entityTypeProvision',
             document,
             variables,
+            transform: (data) => ({
+                entityTypeProvision: data.entityTypeProvisions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class EnumModel {
     } & StrictSelect<S, EnumSelect>): QueryBuilder<{
         enums: ConnectionResult<InferSelectResult<EnumWithRelations, S>>;
     }>;
-    findFirst<S extends EnumSelect>(args: FindFirstArgs<S, EnumFilter> & {
+    findFirst<S extends EnumSelect>(args: FindFirstArgs<S, EnumFilter, EnumOrderBy> & {
         select: S;
     } & StrictSelect<S, EnumSelect>): QueryBuilder<{
-        enums: {
-            nodes: InferSelectResult<EnumWithRelations, S>[];
-        };
+        enum: InferSelectResult<EnumWithRelations, S> | null;
     }>;
     findOne<S extends EnumSelect>(args: {
         id: string;