@constructive-io/react 0.19.5 → 0.19.7

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

@@ -15,12 +15,10 @@ export declare class AppOwnerGrantModel {
     } & StrictSelect<S, AppOwnerGrantSelect>): QueryBuilder<{
         appOwnerGrants: ConnectionResult<InferSelectResult<AppOwnerGrantWithRelations, S>>;
     }>;
-    findFirst<S extends AppOwnerGrantSelect>(args: FindFirstArgs<S, AppOwnerGrantFilter> & {
+    findFirst<S extends AppOwnerGrantSelect>(args: FindFirstArgs<S, AppOwnerGrantFilter, AppOwnerGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, AppOwnerGrantSelect>): QueryBuilder<{
-        appOwnerGrants: {
-            nodes: InferSelectResult<AppOwnerGrantWithRelations, S>[];
-        };
+        appOwnerGrant: InferSelectResult<AppOwnerGrantWithRelations, S> | null;
     }>;
     findOne<S extends AppOwnerGrantSelect>(args: {
         id: string;

package/public/orm/models/appOwnerGrant.js

@@ -30,14 +30,18 @@ class AppOwnerGrantModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AppOwnerGrant', 'appOwnerGrants', args.select, {
             where: args?.where,
-        }, 'AppOwnerGrantFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppOwnerGrantFilter', 'AppOwnerGrantOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AppOwnerGrant',
-            fieldName: 'appOwnerGrants',
+            fieldName: 'appOwnerGrant',
             document,
             variables,
+            transform: (data) => ({
+                appOwnerGrant: data.appOwnerGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class AppPermissionModel {
     } & StrictSelect<S, AppPermissionSelect>): QueryBuilder<{
         appPermissions: ConnectionResult<InferSelectResult<AppPermissionWithRelations, S>>;
     }>;
-    findFirst<S extends AppPermissionSelect>(args: FindFirstArgs<S, AppPermissionFilter> & {
+    findFirst<S extends AppPermissionSelect>(args: FindFirstArgs<S, AppPermissionFilter, AppPermissionOrderBy> & {
         select: S;
     } & StrictSelect<S, AppPermissionSelect>): QueryBuilder<{
-        appPermissions: {
-            nodes: InferSelectResult<AppPermissionWithRelations, S>[];
-        };
+        appPermission: InferSelectResult<AppPermissionWithRelations, S> | null;
     }>;
     findOne<S extends AppPermissionSelect>(args: {
         id: string;

package/public/orm/models/appPermission.js

@@ -30,14 +30,18 @@ class AppPermissionModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AppPermission', 'appPermissions', args.select, {
             where: args?.where,
-        }, 'AppPermissionFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppPermissionFilter', 'AppPermissionOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AppPermission',
-            fieldName: 'appPermissions',
+            fieldName: 'appPermission',
             document,
             variables,
+            transform: (data) => ({
+                appPermission: data.appPermissions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class AppPermissionDefaultModel {
     } & StrictSelect<S, AppPermissionDefaultSelect>): QueryBuilder<{
         appPermissionDefaults: ConnectionResult<InferSelectResult<AppPermissionDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends AppPermissionDefaultSelect>(args: FindFirstArgs<S, AppPermissionDefaultFilter> & {
+    findFirst<S extends AppPermissionDefaultSelect>(args: FindFirstArgs<S, AppPermissionDefaultFilter, AppPermissionDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, AppPermissionDefaultSelect>): QueryBuilder<{
-        appPermissionDefaults: {
-            nodes: InferSelectResult<AppPermissionDefaultWithRelations, S>[];
-        };
+        appPermissionDefault: InferSelectResult<AppPermissionDefaultWithRelations, S> | null;
     }>;
     findOne<S extends AppPermissionDefaultSelect>(args: {
         id: string;

package/public/orm/models/appPermissionDefault.js

@@ -30,14 +30,18 @@ class AppPermissionDefaultModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AppPermissionDefault', 'appPermissionDefaults', args.select, {
             where: args?.where,
-        }, 'AppPermissionDefaultFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppPermissionDefaultFilter', 'AppPermissionDefaultOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AppPermissionDefault',
-            fieldName: 'appPermissionDefaults',
+            fieldName: 'appPermissionDefault',
             document,
             variables,
+            transform: (data) => ({
+                appPermissionDefault: data.appPermissionDefaults?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class AppStepModel {
     } & StrictSelect<S, AppStepSelect>): QueryBuilder<{
         appSteps: ConnectionResult<InferSelectResult<AppStepWithRelations, S>>;
     }>;
-    findFirst<S extends AppStepSelect>(args: FindFirstArgs<S, AppStepFilter> & {
+    findFirst<S extends AppStepSelect>(args: FindFirstArgs<S, AppStepFilter, AppStepOrderBy> & {
         select: S;
     } & StrictSelect<S, AppStepSelect>): QueryBuilder<{
-        appSteps: {
-            nodes: InferSelectResult<AppStepWithRelations, S>[];
-        };
+        appStep: InferSelectResult<AppStepWithRelations, S> | null;
     }>;
     findOne<S extends AppStepSelect>(args: {
         id: string;

package/public/orm/models/appStep.js

@@ -30,14 +30,18 @@ class AppStepModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AppStep', 'appSteps', args.select, {
             where: args?.where,
-        }, 'AppStepFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AppStepFilter', 'AppStepOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AppStep',
-            fieldName: 'appSteps',
+            fieldName: 'appStep',
             document,
             variables,
+            transform: (data) => ({
+                appStep: data.appSteps?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class AstMigrationModel {
     } & StrictSelect<S, AstMigrationSelect>): QueryBuilder<{
         astMigrations: ConnectionResult<InferSelectResult<AstMigrationWithRelations, S>>;
     }>;
-    findFirst<S extends AstMigrationSelect>(args: FindFirstArgs<S, AstMigrationFilter> & {
+    findFirst<S extends AstMigrationSelect>(args: FindFirstArgs<S, AstMigrationFilter, AstMigrationOrderBy> & {
         select: S;
     } & StrictSelect<S, AstMigrationSelect>): QueryBuilder<{
-        astMigrations: {
-            nodes: InferSelectResult<AstMigrationWithRelations, S>[];
-        };
+        astMigration: InferSelectResult<AstMigrationWithRelations, S> | null;
     }>;
     findOne<S extends AstMigrationSelect>(args: {
         id: number;

package/public/orm/models/astMigration.js

@@ -30,14 +30,18 @@ class AstMigrationModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AstMigration', 'astMigrations', args.select, {
             where: args?.where,
-        }, 'AstMigrationFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AstMigrationFilter', 'AstMigrationOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AstMigration',
-            fieldName: 'astMigrations',
+            fieldName: 'astMigration',
             document,
             variables,
+            transform: (data) => ({
+                astMigration: data.astMigrations?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class AuditLogModel {
     } & StrictSelect<S, AuditLogSelect>): QueryBuilder<{
         auditLogs: ConnectionResult<InferSelectResult<AuditLogWithRelations, S>>;
     }>;
-    findFirst<S extends AuditLogSelect>(args: FindFirstArgs<S, AuditLogFilter> & {
+    findFirst<S extends AuditLogSelect>(args: FindFirstArgs<S, AuditLogFilter, AuditLogOrderBy> & {
         select: S;
     } & StrictSelect<S, AuditLogSelect>): QueryBuilder<{
-        auditLogs: {
-            nodes: InferSelectResult<AuditLogWithRelations, S>[];
-        };
+        auditLog: InferSelectResult<AuditLogWithRelations, S> | null;
     }>;
     findOne<S extends AuditLogSelect>(args: {
         id: string;

package/public/orm/models/auditLog.js

@@ -30,14 +30,18 @@ class AuditLogModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('AuditLog', 'auditLogs', args.select, {
             where: args?.where,
-        }, 'AuditLogFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'AuditLogFilter', 'AuditLogOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'AuditLog',
-            fieldName: 'auditLogs',
+            fieldName: 'auditLog',
             document,
             variables,
+            transform: (data) => ({
+                auditLog: data.auditLogs?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BillingModuleModel {
     } & StrictSelect<S, BillingModuleSelect>): QueryBuilder<{
         billingModules: ConnectionResult<InferSelectResult<BillingModuleWithRelations, S>>;
     }>;
-    findFirst<S extends BillingModuleSelect>(args: FindFirstArgs<S, BillingModuleFilter> & {
+    findFirst<S extends BillingModuleSelect>(args: FindFirstArgs<S, BillingModuleFilter, BillingModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, BillingModuleSelect>): QueryBuilder<{
-        billingModules: {
-            nodes: InferSelectResult<BillingModuleWithRelations, S>[];
-        };
+        billingModule: InferSelectResult<BillingModuleWithRelations, S> | null;
     }>;
     findOne<S extends BillingModuleSelect>(args: {
         id: string;

package/public/orm/models/billingModule.js

@@ -30,14 +30,18 @@ class BillingModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('BillingModule', 'billingModules', args.select, {
             where: args?.where,
-        }, 'BillingModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BillingModuleFilter', 'BillingModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BillingModule',
-            fieldName: 'billingModules',
+            fieldName: 'billingModule',
             document,
             variables,
+            transform: (data) => ({
+                billingModule: data.billingModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BillingProviderModuleModel {
     } & StrictSelect<S, BillingProviderModuleSelect>): QueryBuilder<{
         billingProviderModules: ConnectionResult<InferSelectResult<BillingProviderModuleWithRelations, S>>;
     }>;
-    findFirst<S extends BillingProviderModuleSelect>(args: FindFirstArgs<S, BillingProviderModuleFilter> & {
+    findFirst<S extends BillingProviderModuleSelect>(args: FindFirstArgs<S, BillingProviderModuleFilter, BillingProviderModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, BillingProviderModuleSelect>): QueryBuilder<{
-        billingProviderModules: {
-            nodes: InferSelectResult<BillingProviderModuleWithRelations, S>[];
-        };
+        billingProviderModule: InferSelectResult<BillingProviderModuleWithRelations, S> | null;
     }>;
     findOne<S extends BillingProviderModuleSelect>(args: {
         id: string;

package/public/orm/models/billingProviderModule.js

@@ -30,14 +30,18 @@ class BillingProviderModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('BillingProviderModule', 'billingProviderModules', args.select, {
             where: args?.where,
-        }, 'BillingProviderModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BillingProviderModuleFilter', 'BillingProviderModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BillingProviderModule',
-            fieldName: 'billingProviderModules',
+            fieldName: 'billingProviderModule',
             document,
             variables,
+            transform: (data) => ({
+                billingProviderModule: data.billingProviderModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintModel {
     } & StrictSelect<S, BlueprintSelect>): QueryBuilder<{
         blueprints: ConnectionResult<InferSelectResult<BlueprintWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintSelect>(args: FindFirstArgs<S, BlueprintFilter> & {
+    findFirst<S extends BlueprintSelect>(args: FindFirstArgs<S, BlueprintFilter, BlueprintOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintSelect>): QueryBuilder<{
-        blueprints: {
-            nodes: InferSelectResult<BlueprintWithRelations, S>[];
-        };
+        blueprint: InferSelectResult<BlueprintWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintSelect>(args: {
         id: string;

package/public/orm/models/blueprint.js

@@ -30,14 +30,18 @@ class BlueprintModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('Blueprint', 'blueprints', args.select, {
             where: args?.where,
-        }, 'BlueprintFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintFilter', 'BlueprintOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Blueprint',
-            fieldName: 'blueprints',
+            fieldName: 'blueprint',
             document,
             variables,
+            transform: (data) => ({
+                blueprint: data.blueprints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintConstructionModel {
     } & StrictSelect<S, BlueprintConstructionSelect>): QueryBuilder<{
         blueprintConstructions: ConnectionResult<InferSelectResult<BlueprintConstructionWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintConstructionSelect>(args: FindFirstArgs<S, BlueprintConstructionFilter> & {
+    findFirst<S extends BlueprintConstructionSelect>(args: FindFirstArgs<S, BlueprintConstructionFilter, BlueprintConstructionOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintConstructionSelect>): QueryBuilder<{
-        blueprintConstructions: {
-            nodes: InferSelectResult<BlueprintConstructionWithRelations, S>[];
-        };
+        blueprintConstruction: InferSelectResult<BlueprintConstructionWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintConstructionSelect>(args: {
         id: string;

package/public/orm/models/blueprintConstruction.js

@@ -30,14 +30,18 @@ class BlueprintConstructionModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('BlueprintConstruction', 'blueprintConstructions', args.select, {
             where: args?.where,
-        }, 'BlueprintConstructionFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintConstructionFilter', 'BlueprintConstructionOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintConstruction',
-            fieldName: 'blueprintConstructions',
+            fieldName: 'blueprintConstruction',
             document,
             variables,
+            transform: (data) => ({
+                blueprintConstruction: data.blueprintConstructions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class BlueprintTemplateModel {
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
         blueprintTemplates: ConnectionResult<InferSelectResult<BlueprintTemplateWithRelations, S>>;
     }>;
-    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter> & {
+    findFirst<S extends BlueprintTemplateSelect>(args: FindFirstArgs<S, BlueprintTemplateFilter, BlueprintTemplateOrderBy> & {
         select: S;
     } & StrictSelect<S, BlueprintTemplateSelect>): QueryBuilder<{
-        blueprintTemplates: {
-            nodes: InferSelectResult<BlueprintTemplateWithRelations, S>[];
-        };
+        blueprintTemplate: InferSelectResult<BlueprintTemplateWithRelations, S> | null;
     }>;
     findOne<S extends BlueprintTemplateSelect>(args: {
         id: string;

package/public/orm/models/blueprintTemplate.js

@@ -30,14 +30,18 @@ class BlueprintTemplateModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('BlueprintTemplate', 'blueprintTemplates', args.select, {
             where: args?.where,
-        }, 'BlueprintTemplateFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'BlueprintTemplateFilter', 'BlueprintTemplateOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'BlueprintTemplate',
-            fieldName: 'blueprintTemplates',
+            fieldName: 'blueprintTemplate',
             document,
             variables,
+            transform: (data) => ({
+                blueprintTemplate: data.blueprintTemplates?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CheckConstraintModel {
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
         checkConstraints: ConnectionResult<InferSelectResult<CheckConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter> & {
+    findFirst<S extends CheckConstraintSelect>(args: FindFirstArgs<S, CheckConstraintFilter, CheckConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, CheckConstraintSelect>): QueryBuilder<{
-        checkConstraints: {
-            nodes: InferSelectResult<CheckConstraintWithRelations, S>[];
-        };
+        checkConstraint: InferSelectResult<CheckConstraintWithRelations, S> | null;
     }>;
     findOne<S extends CheckConstraintSelect>(args: {
         id: string;

package/public/orm/models/checkConstraint.js

@@ -30,14 +30,18 @@ class CheckConstraintModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('CheckConstraint', 'checkConstraints', args.select, {
             where: args?.where,
-        }, 'CheckConstraintFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CheckConstraintFilter', 'CheckConstraintOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CheckConstraint',
-            fieldName: 'checkConstraints',
+            fieldName: 'checkConstraint',
             document,
             variables,
+            transform: (data) => ({
+                checkConstraint: data.checkConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CommitModel {
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
         commits: ConnectionResult<InferSelectResult<CommitWithRelations, S>>;
     }>;
-    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter> & {
+    findFirst<S extends CommitSelect>(args: FindFirstArgs<S, CommitFilter, CommitOrderBy> & {
         select: S;
     } & StrictSelect<S, CommitSelect>): QueryBuilder<{
-        commits: {
-            nodes: InferSelectResult<CommitWithRelations, S>[];
-        };
+        commit: InferSelectResult<CommitWithRelations, S> | null;
     }>;
     findOne<S extends CommitSelect>(args: {
         id: string;

package/public/orm/models/commit.js

@@ -30,14 +30,18 @@ class CommitModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('Commit', 'commits', args.select, {
             where: args?.where,
-        }, 'CommitFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CommitFilter', 'CommitOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Commit',
-            fieldName: 'commits',
+            fieldName: 'commit',
             document,
             variables,
+            transform: (data) => ({
+                commit: data.commits?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class ConnectedAccountsModuleModel {
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
         connectedAccountsModules: ConnectionResult<InferSelectResult<ConnectedAccountsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter> & {
+    findFirst<S extends ConnectedAccountsModuleSelect>(args: FindFirstArgs<S, ConnectedAccountsModuleFilter, ConnectedAccountsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ConnectedAccountsModuleSelect>): QueryBuilder<{
-        connectedAccountsModules: {
-            nodes: InferSelectResult<ConnectedAccountsModuleWithRelations, S>[];
-        };
+        connectedAccountsModule: InferSelectResult<ConnectedAccountsModuleWithRelations, S> | null;
     }>;
     findOne<S extends ConnectedAccountsModuleSelect>(args: {
         id: string;

package/public/orm/models/connectedAccountsModule.js

@@ -30,14 +30,18 @@ class ConnectedAccountsModuleModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ConnectedAccountsModule', 'connectedAccountsModules', args.select, {
             where: args?.where,
-        }, 'ConnectedAccountsModuleFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ConnectedAccountsModuleFilter', 'ConnectedAccountsModuleOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'ConnectedAccountsModule',
-            fieldName: 'connectedAccountsModules',
+            fieldName: 'connectedAccountsModule',
             document,
             variables,
+            transform: (data) => ({
+                connectedAccountsModule: data.connectedAccountsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CorsSettingModel {
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
         corsSettings: ConnectionResult<InferSelectResult<CorsSettingWithRelations, S>>;
     }>;
-    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter> & {
+    findFirst<S extends CorsSettingSelect>(args: FindFirstArgs<S, CorsSettingFilter, CorsSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, CorsSettingSelect>): QueryBuilder<{
-        corsSettings: {
-            nodes: InferSelectResult<CorsSettingWithRelations, S>[];
-        };
+        corsSetting: InferSelectResult<CorsSettingWithRelations, S> | null;
     }>;
     findOne<S extends CorsSettingSelect>(args: {
         id: string;

package/public/orm/models/corsSetting.js

@@ -30,14 +30,18 @@ class CorsSettingModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('CorsSetting', 'corsSettings', args.select, {
             where: args?.where,
-        }, 'CorsSettingFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CorsSettingFilter', 'CorsSettingOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CorsSetting',
-            fieldName: 'corsSettings',
+            fieldName: 'corsSetting',
             document,
             variables,
+            transform: (data) => ({
+                corsSetting: data.corsSettings?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class CryptoAddressModel {
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
         cryptoAddresses: ConnectionResult<InferSelectResult<CryptoAddressWithRelations, S>>;
     }>;
-    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter> & {
+    findFirst<S extends CryptoAddressSelect>(args: FindFirstArgs<S, CryptoAddressFilter, CryptoAddressOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAddressSelect>): QueryBuilder<{
-        cryptoAddresses: {
-            nodes: InferSelectResult<CryptoAddressWithRelations, S>[];
-        };
+        cryptoAddress: InferSelectResult<CryptoAddressWithRelations, S> | null;
     }>;
     findOne<S extends CryptoAddressSelect>(args: {
         id: string;

package/public/orm/models/cryptoAddress.js

@@ -30,14 +30,18 @@ class CryptoAddressModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('CryptoAddress', 'cryptoAddresses', args.select, {
             where: args?.where,
-        }, 'CryptoAddressFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'CryptoAddressFilter', 'CryptoAddressOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'CryptoAddress',
-            fieldName: 'cryptoAddresses',
+            fieldName: 'cryptoAddress',
             document,
             variables,
+            transform: (data) => ({
+                cryptoAddress: data.cryptoAddresses?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/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;