@constructive-io/react 0.19.6 → 0.19.8

package/public/orm/models/indexModel.js

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

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

@@ -15,12 +15,10 @@ export declare class InvitesModuleModel {
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
         invitesModules: ConnectionResult<InferSelectResult<InvitesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter> & {
+    findFirst<S extends InvitesModuleSelect>(args: FindFirstArgs<S, InvitesModuleFilter, InvitesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
-        invitesModules: {
-            nodes: InferSelectResult<InvitesModuleWithRelations, S>[];
-        };
+        invitesModule: InferSelectResult<InvitesModuleWithRelations, S> | null;
     }>;
     findOne<S extends InvitesModuleSelect>(args: {
         id: string;

package/public/orm/models/invitesModule.js

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

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

@@ -15,12 +15,10 @@ export declare class LevelsModuleModel {
     } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
         levelsModules: ConnectionResult<InferSelectResult<LevelsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends LevelsModuleSelect>(args: FindFirstArgs<S, LevelsModuleFilter> & {
+    findFirst<S extends LevelsModuleSelect>(args: FindFirstArgs<S, LevelsModuleFilter, LevelsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
-        levelsModules: {
-            nodes: InferSelectResult<LevelsModuleWithRelations, S>[];
-        };
+        levelsModule: InferSelectResult<LevelsModuleWithRelations, S> | null;
     }>;
     findOne<S extends LevelsModuleSelect>(args: {
         id: string;

package/public/orm/models/levelsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class LimitsModuleModel {
     } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
         limitsModules: ConnectionResult<InferSelectResult<LimitsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends LimitsModuleSelect>(args: FindFirstArgs<S, LimitsModuleFilter> & {
+    findFirst<S extends LimitsModuleSelect>(args: FindFirstArgs<S, LimitsModuleFilter, LimitsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
-        limitsModules: {
-            nodes: InferSelectResult<LimitsModuleWithRelations, S>[];
-        };
+        limitsModule: InferSelectResult<LimitsModuleWithRelations, S> | null;
     }>;
     findOne<S extends LimitsModuleSelect>(args: {
         id: string;

package/public/orm/models/limitsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipTypeModel {
     } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
         membershipTypes: ConnectionResult<InferSelectResult<MembershipTypeWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipTypeSelect>(args: FindFirstArgs<S, MembershipTypeFilter> & {
+    findFirst<S extends MembershipTypeSelect>(args: FindFirstArgs<S, MembershipTypeFilter, MembershipTypeOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
-        membershipTypes: {
-            nodes: InferSelectResult<MembershipTypeWithRelations, S>[];
-        };
+        membershipType: InferSelectResult<MembershipTypeWithRelations, S> | null;
     }>;
     findOne<S extends MembershipTypeSelect>(args: {
         id: number;

package/public/orm/models/membershipType.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipTypesModuleModel {
     } & StrictSelect<S, MembershipTypesModuleSelect>): QueryBuilder<{
         membershipTypesModules: ConnectionResult<InferSelectResult<MembershipTypesModuleWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipTypesModuleSelect>(args: FindFirstArgs<S, MembershipTypesModuleFilter> & {
+    findFirst<S extends MembershipTypesModuleSelect>(args: FindFirstArgs<S, MembershipTypesModuleFilter, MembershipTypesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypesModuleSelect>): QueryBuilder<{
-        membershipTypesModules: {
-            nodes: InferSelectResult<MembershipTypesModuleWithRelations, S>[];
-        };
+        membershipTypesModule: InferSelectResult<MembershipTypesModuleWithRelations, S> | null;
     }>;
     findOne<S extends MembershipTypesModuleSelect>(args: {
         id: string;

package/public/orm/models/membershipTypesModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MembershipsModuleModel {
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
         membershipsModules: ConnectionResult<InferSelectResult<MembershipsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends MembershipsModuleSelect>(args: FindFirstArgs<S, MembershipsModuleFilter> & {
+    findFirst<S extends MembershipsModuleSelect>(args: FindFirstArgs<S, MembershipsModuleFilter, MembershipsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
-        membershipsModules: {
-            nodes: InferSelectResult<MembershipsModuleWithRelations, S>[];
-        };
+        membershipsModule: InferSelectResult<MembershipsModuleWithRelations, S> | null;
     }>;
     findOne<S extends MembershipsModuleSelect>(args: {
         id: string;

package/public/orm/models/membershipsModule.js

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

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

@@ -15,12 +15,10 @@ export declare class MigrateFileModel {
     } & StrictSelect<S, MigrateFileSelect>): QueryBuilder<{
         migrateFiles: ConnectionResult<InferSelectResult<MigrateFileWithRelations, S>>;
     }>;
-    findFirst<S extends MigrateFileSelect>(args: FindFirstArgs<S, MigrateFileFilter> & {
+    findFirst<S extends MigrateFileSelect>(args: FindFirstArgs<S, MigrateFileFilter, MigrateFileOrderBy> & {
         select: S;
     } & StrictSelect<S, MigrateFileSelect>): QueryBuilder<{
-        migrateFiles: {
-            nodes: InferSelectResult<MigrateFileWithRelations, S>[];
-        };
+        migrateFile: InferSelectResult<MigrateFileWithRelations, S> | null;
     }>;
     findOne<S extends MigrateFileSelect>(args: {
         id: string;

package/public/orm/models/migrateFile.js

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

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

@@ -15,12 +15,10 @@ export declare class NodeTypeRegistryModel {
     } & StrictSelect<S, NodeTypeRegistrySelect>): QueryBuilder<{
         nodeTypeRegistries: ConnectionResult<InferSelectResult<NodeTypeRegistryWithRelations, S>>;
     }>;
-    findFirst<S extends NodeTypeRegistrySelect>(args: FindFirstArgs<S, NodeTypeRegistryFilter> & {
+    findFirst<S extends NodeTypeRegistrySelect>(args: FindFirstArgs<S, NodeTypeRegistryFilter, NodeTypeRegistryOrderBy> & {
         select: S;
     } & StrictSelect<S, NodeTypeRegistrySelect>): QueryBuilder<{
-        nodeTypeRegistries: {
-            nodes: InferSelectResult<NodeTypeRegistryWithRelations, S>[];
-        };
+        nodeTypeRegistry: InferSelectResult<NodeTypeRegistryWithRelations, S> | null;
     }>;
     findOne<S extends NodeTypeRegistrySelect>(args: {
         name: string;

package/public/orm/models/nodeTypeRegistry.js

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

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

@@ -15,12 +15,10 @@ export declare class NotificationsModuleModel {
     } & StrictSelect<S, NotificationsModuleSelect>): QueryBuilder<{
         notificationsModules: ConnectionResult<InferSelectResult<NotificationsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends NotificationsModuleSelect>(args: FindFirstArgs<S, NotificationsModuleFilter> & {
+    findFirst<S extends NotificationsModuleSelect>(args: FindFirstArgs<S, NotificationsModuleFilter, NotificationsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, NotificationsModuleSelect>): QueryBuilder<{
-        notificationsModules: {
-            nodes: InferSelectResult<NotificationsModuleWithRelations, S>[];
-        };
+        notificationsModule: InferSelectResult<NotificationsModuleWithRelations, S> | null;
     }>;
     findOne<S extends NotificationsModuleSelect>(args: {
         id: string;

package/public/orm/models/notificationsModule.js

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

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

@@ -15,18 +15,16 @@ export declare class ObjectModel {
     } & StrictSelect<S, ObjectSelect>): QueryBuilder<{
         objects: ConnectionResult<InferSelectResult<ObjectWithRelations, S>>;
     }>;
-    findFirst<S extends ObjectSelect>(args: FindFirstArgs<S, ObjectFilter> & {
+    findFirst<S extends ObjectSelect>(args: FindFirstArgs<S, ObjectFilter, ObjectOrderBy> & {
         select: S;
     } & StrictSelect<S, ObjectSelect>): QueryBuilder<{
-        objects: {
-            nodes: InferSelectResult<ObjectWithRelations, S>[];
-        };
+        object: InferSelectResult<ObjectWithRelations, S> | null;
     }>;
     findOne<S extends ObjectSelect>(args: {
         id: string;
         select: S;
     } & StrictSelect<S, ObjectSelect>): QueryBuilder<{
-        getNodeAtPath: InferSelectResult<ObjectWithRelations, S> | null;
+        object: InferSelectResult<ObjectWithRelations, S> | null;
     }>;
     create<S extends ObjectSelect>(args: CreateArgs<S, CreateObjectInput['object']> & {
         select: S;

package/public/orm/models/object.js

@@ -30,14 +30,18 @@ class ObjectModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('Object', 'objects', args.select, {
             where: args?.where,
-        }, 'ObjectFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'ObjectFilter', 'ObjectOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Object',
-            fieldName: 'objects',
+            fieldName: 'object',
             document,
             variables,
+            transform: (data) => ({
+                object: data.objects?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {
@@ -46,7 +50,7 @@ class ObjectModel {
             client: this.client,
             operation: 'query',
             operationName: 'Object',
-            fieldName: 'getNodeAtPath',
+            fieldName: 'object',
             document,
             variables,
         });

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

@@ -15,12 +15,10 @@ export declare class OrgAdminGrantModel {
     } & StrictSelect<S, OrgAdminGrantSelect>): QueryBuilder<{
         orgAdminGrants: ConnectionResult<InferSelectResult<OrgAdminGrantWithRelations, S>>;
     }>;
-    findFirst<S extends OrgAdminGrantSelect>(args: FindFirstArgs<S, OrgAdminGrantFilter> & {
+    findFirst<S extends OrgAdminGrantSelect>(args: FindFirstArgs<S, OrgAdminGrantFilter, OrgAdminGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgAdminGrantSelect>): QueryBuilder<{
-        orgAdminGrants: {
-            nodes: InferSelectResult<OrgAdminGrantWithRelations, S>[];
-        };
+        orgAdminGrant: InferSelectResult<OrgAdminGrantWithRelations, S> | null;
     }>;
     findOne<S extends OrgAdminGrantSelect>(args: {
         id: string;

package/public/orm/models/orgAdminGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgChartEdgeModel {
     } & StrictSelect<S, OrgChartEdgeSelect>): QueryBuilder<{
         orgChartEdges: ConnectionResult<InferSelectResult<OrgChartEdgeWithRelations, S>>;
     }>;
-    findFirst<S extends OrgChartEdgeSelect>(args: FindFirstArgs<S, OrgChartEdgeFilter> & {
+    findFirst<S extends OrgChartEdgeSelect>(args: FindFirstArgs<S, OrgChartEdgeFilter, OrgChartEdgeOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgChartEdgeSelect>): QueryBuilder<{
-        orgChartEdges: {
-            nodes: InferSelectResult<OrgChartEdgeWithRelations, S>[];
-        };
+        orgChartEdge: InferSelectResult<OrgChartEdgeWithRelations, S> | null;
     }>;
     findOne<S extends OrgChartEdgeSelect>(args: {
         id: string;

package/public/orm/models/orgChartEdge.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgChartEdgeGrantModel {
     } & StrictSelect<S, OrgChartEdgeGrantSelect>): QueryBuilder<{
         orgChartEdgeGrants: ConnectionResult<InferSelectResult<OrgChartEdgeGrantWithRelations, S>>;
     }>;
-    findFirst<S extends OrgChartEdgeGrantSelect>(args: FindFirstArgs<S, OrgChartEdgeGrantFilter> & {
+    findFirst<S extends OrgChartEdgeGrantSelect>(args: FindFirstArgs<S, OrgChartEdgeGrantFilter, OrgChartEdgeGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgChartEdgeGrantSelect>): QueryBuilder<{
-        orgChartEdgeGrants: {
-            nodes: InferSelectResult<OrgChartEdgeGrantWithRelations, S>[];
-        };
+        orgChartEdgeGrant: InferSelectResult<OrgChartEdgeGrantWithRelations, S> | null;
     }>;
     findOne<S extends OrgChartEdgeGrantSelect>(args: {
         id: string;

package/public/orm/models/orgChartEdgeGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgClaimedInviteModel {
     } & StrictSelect<S, OrgClaimedInviteSelect>): QueryBuilder<{
         orgClaimedInvites: ConnectionResult<InferSelectResult<OrgClaimedInviteWithRelations, S>>;
     }>;
-    findFirst<S extends OrgClaimedInviteSelect>(args: FindFirstArgs<S, OrgClaimedInviteFilter> & {
+    findFirst<S extends OrgClaimedInviteSelect>(args: FindFirstArgs<S, OrgClaimedInviteFilter, OrgClaimedInviteOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgClaimedInviteSelect>): QueryBuilder<{
-        orgClaimedInvites: {
-            nodes: InferSelectResult<OrgClaimedInviteWithRelations, S>[];
-        };
+        orgClaimedInvite: InferSelectResult<OrgClaimedInviteWithRelations, S> | null;
     }>;
     findOne<S extends OrgClaimedInviteSelect>(args: {
         id: string;

package/public/orm/models/orgClaimedInvite.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgGetManagersRecordModel {
     } & StrictSelect<S, OrgGetManagersRecordSelect>): QueryBuilder<{
         orgGetManagers: ConnectionResult<InferSelectResult<OrgGetManagersRecordWithRelations, S>>;
     }>;
-    findFirst<S extends OrgGetManagersRecordSelect>(args: FindFirstArgs<S, OrgGetManagersRecordFilter> & {
+    findFirst<S extends OrgGetManagersRecordSelect>(args: FindFirstArgs<S, OrgGetManagersRecordFilter, OrgGetManagersRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgGetManagersRecordSelect>): QueryBuilder<{
-        orgGetManagers: {
-            nodes: InferSelectResult<OrgGetManagersRecordWithRelations, S>[];
-        };
+        orgGetManagersRecord: InferSelectResult<OrgGetManagersRecordWithRelations, S> | null;
     }>;
     create<S extends OrgGetManagersRecordSelect>(args: CreateArgs<S, CreateOrgGetManagersRecordInput['orgGetManagersRecord']> & {
         select: S;

package/public/orm/models/orgGetManagersRecord.js

@@ -30,14 +30,18 @@ class OrgGetManagersRecordModel {
     findFirst(args) {
         const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('OrgGetManagersRecord', 'orgGetManagers', args.select, {
             where: args?.where,
-        }, 'OrgGetManagersRecordFilter', input_types_1.connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgGetManagersRecordFilter', 'OrgGetManagersRecordsOrderBy', input_types_1.connectionFieldsMap);
         return new query_builder_1.QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'OrgGetManagersRecord',
-            fieldName: 'orgGetManagers',
+            fieldName: 'orgGetManagersRecord',
             document,
             variables,
+            transform: (data) => ({
+                orgGetManagersRecord: data.orgGetManagers?.nodes?.[0] ?? null,
+            }),
         });
     }
     create(args) {

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

@@ -15,12 +15,10 @@ export declare class OrgGetSubordinatesRecordModel {
     } & StrictSelect<S, OrgGetSubordinatesRecordSelect>): QueryBuilder<{
         orgGetSubordinates: ConnectionResult<InferSelectResult<OrgGetSubordinatesRecordWithRelations, S>>;
     }>;
-    findFirst<S extends OrgGetSubordinatesRecordSelect>(args: FindFirstArgs<S, OrgGetSubordinatesRecordFilter> & {
+    findFirst<S extends OrgGetSubordinatesRecordSelect>(args: FindFirstArgs<S, OrgGetSubordinatesRecordFilter, OrgGetSubordinatesRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgGetSubordinatesRecordSelect>): QueryBuilder<{
-        orgGetSubordinates: {
-            nodes: InferSelectResult<OrgGetSubordinatesRecordWithRelations, S>[];
-        };
+        orgGetSubordinatesRecord: InferSelectResult<OrgGetSubordinatesRecordWithRelations, S> | null;
     }>;
     create<S extends OrgGetSubordinatesRecordSelect>(args: CreateArgs<S, CreateOrgGetSubordinatesRecordInput['orgGetSubordinatesRecord']> & {
         select: S;