@constructive-sdk/cli 0.21.6 → 0.21.7

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

@@ -15,12 +15,10 @@ export declare class OrgLimitModel {
     } & StrictSelect<S, OrgLimitSelect>): QueryBuilder<{
         orgLimits: ConnectionResult<InferSelectResult<OrgLimitWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitSelect>(args: FindFirstArgs<S, OrgLimitFilter> & {
+    findFirst<S extends OrgLimitSelect>(args: FindFirstArgs<S, OrgLimitFilter, OrgLimitOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitSelect>): QueryBuilder<{
-        orgLimits: {
-            nodes: InferSelectResult<OrgLimitWithRelations, S>[];
-        };
+        orgLimit: InferSelectResult<OrgLimitWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitSelect>(args: {
         id: string;

package/public/orm/models/orgLimit.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitAggregateModel {
     } & StrictSelect<S, OrgLimitAggregateSelect>): QueryBuilder<{
         orgLimitAggregates: ConnectionResult<InferSelectResult<OrgLimitAggregateWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitAggregateSelect>(args: FindFirstArgs<S, OrgLimitAggregateFilter> & {
+    findFirst<S extends OrgLimitAggregateSelect>(args: FindFirstArgs<S, OrgLimitAggregateFilter, OrgLimitAggregateOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitAggregateSelect>): QueryBuilder<{
-        orgLimitAggregates: {
-            nodes: InferSelectResult<OrgLimitAggregateWithRelations, S>[];
-        };
+        orgLimitAggregate: InferSelectResult<OrgLimitAggregateWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitAggregateSelect>(args: {
         id: string;

package/public/orm/models/orgLimitAggregate.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitCapModel {
     } & StrictSelect<S, OrgLimitCapSelect>): QueryBuilder<{
         orgLimitCaps: ConnectionResult<InferSelectResult<OrgLimitCapWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitCapSelect>(args: FindFirstArgs<S, OrgLimitCapFilter> & {
+    findFirst<S extends OrgLimitCapSelect>(args: FindFirstArgs<S, OrgLimitCapFilter, OrgLimitCapOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitCapSelect>): QueryBuilder<{
-        orgLimitCaps: {
-            nodes: InferSelectResult<OrgLimitCapWithRelations, S>[];
-        };
+        orgLimitCap: InferSelectResult<OrgLimitCapWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitCapSelect>(args: {
         id: string;

package/public/orm/models/orgLimitCap.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitCapsDefaultModel {
     } & StrictSelect<S, OrgLimitCapsDefaultSelect>): QueryBuilder<{
         orgLimitCapsDefaults: ConnectionResult<InferSelectResult<OrgLimitCapsDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitCapsDefaultSelect>(args: FindFirstArgs<S, OrgLimitCapsDefaultFilter> & {
+    findFirst<S extends OrgLimitCapsDefaultSelect>(args: FindFirstArgs<S, OrgLimitCapsDefaultFilter, OrgLimitCapsDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitCapsDefaultSelect>): QueryBuilder<{
-        orgLimitCapsDefaults: {
-            nodes: InferSelectResult<OrgLimitCapsDefaultWithRelations, S>[];
-        };
+        orgLimitCapsDefault: InferSelectResult<OrgLimitCapsDefaultWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitCapsDefaultSelect>(args: {
         id: string;

package/public/orm/models/orgLimitCapsDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitCreditModel {
     } & StrictSelect<S, OrgLimitCreditSelect>): QueryBuilder<{
         orgLimitCredits: ConnectionResult<InferSelectResult<OrgLimitCreditWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitCreditSelect>(args: FindFirstArgs<S, OrgLimitCreditFilter> & {
+    findFirst<S extends OrgLimitCreditSelect>(args: FindFirstArgs<S, OrgLimitCreditFilter, OrgLimitCreditOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitCreditSelect>): QueryBuilder<{
-        orgLimitCredits: {
-            nodes: InferSelectResult<OrgLimitCreditWithRelations, S>[];
-        };
+        orgLimitCredit: InferSelectResult<OrgLimitCreditWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitCreditSelect>(args: {
         id: string;

package/public/orm/models/orgLimitCredit.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitDefaultModel {
     } & StrictSelect<S, OrgLimitDefaultSelect>): QueryBuilder<{
         orgLimitDefaults: ConnectionResult<InferSelectResult<OrgLimitDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitDefaultSelect>(args: FindFirstArgs<S, OrgLimitDefaultFilter> & {
+    findFirst<S extends OrgLimitDefaultSelect>(args: FindFirstArgs<S, OrgLimitDefaultFilter, OrgLimitDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitDefaultSelect>): QueryBuilder<{
-        orgLimitDefaults: {
-            nodes: InferSelectResult<OrgLimitDefaultWithRelations, S>[];
-        };
+        orgLimitDefault: InferSelectResult<OrgLimitDefaultWithRelations, S> | null;
     }>;
     findOne<S extends OrgLimitDefaultSelect>(args: {
         id: string;

package/public/orm/models/orgLimitDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgLimitEventModel {
     } & StrictSelect<S, OrgLimitEventSelect>): QueryBuilder<{
         orgLimitEvents: ConnectionResult<InferSelectResult<OrgLimitEventWithRelations, S>>;
     }>;
-    findFirst<S extends OrgLimitEventSelect>(args: FindFirstArgs<S, OrgLimitEventFilter> & {
+    findFirst<S extends OrgLimitEventSelect>(args: FindFirstArgs<S, OrgLimitEventFilter, OrgLimitEventOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitEventSelect>): QueryBuilder<{
-        orgLimitEvents: {
-            nodes: InferSelectResult<OrgLimitEventWithRelations, S>[];
-        };
+        orgLimitEvent: InferSelectResult<OrgLimitEventWithRelations, S> | null;
     }>;
     create<S extends OrgLimitEventSelect>(args: CreateArgs<S, CreateOrgLimitEventInput['orgLimitEvent']> & {
         select: S;

package/public/orm/models/orgLimitEvent.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgMemberModel {
     } & StrictSelect<S, OrgMemberSelect>): QueryBuilder<{
         orgMembers: ConnectionResult<InferSelectResult<OrgMemberWithRelations, S>>;
     }>;
-    findFirst<S extends OrgMemberSelect>(args: FindFirstArgs<S, OrgMemberFilter> & {
+    findFirst<S extends OrgMemberSelect>(args: FindFirstArgs<S, OrgMemberFilter, OrgMemberOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMemberSelect>): QueryBuilder<{
-        orgMembers: {
-            nodes: InferSelectResult<OrgMemberWithRelations, S>[];
-        };
+        orgMember: InferSelectResult<OrgMemberWithRelations, S> | null;
     }>;
     findOne<S extends OrgMemberSelect>(args: {
         id: string;

package/public/orm/models/orgMember.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgMemberProfileModel {
     } & StrictSelect<S, OrgMemberProfileSelect>): QueryBuilder<{
         orgMemberProfiles: ConnectionResult<InferSelectResult<OrgMemberProfileWithRelations, S>>;
     }>;
-    findFirst<S extends OrgMemberProfileSelect>(args: FindFirstArgs<S, OrgMemberProfileFilter> & {
+    findFirst<S extends OrgMemberProfileSelect>(args: FindFirstArgs<S, OrgMemberProfileFilter, OrgMemberProfileOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMemberProfileSelect>): QueryBuilder<{
-        orgMemberProfiles: {
-            nodes: InferSelectResult<OrgMemberProfileWithRelations, S>[];
-        };
+        orgMemberProfile: InferSelectResult<OrgMemberProfileWithRelations, S> | null;
     }>;
     findOne<S extends OrgMemberProfileSelect>(args: {
         id: string;

package/public/orm/models/orgMemberProfile.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgMembershipModel {
     } & StrictSelect<S, OrgMembershipSelect>): QueryBuilder<{
         orgMemberships: ConnectionResult<InferSelectResult<OrgMembershipWithRelations, S>>;
     }>;
-    findFirst<S extends OrgMembershipSelect>(args: FindFirstArgs<S, OrgMembershipFilter> & {
+    findFirst<S extends OrgMembershipSelect>(args: FindFirstArgs<S, OrgMembershipFilter, OrgMembershipOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMembershipSelect>): QueryBuilder<{
-        orgMemberships: {
-            nodes: InferSelectResult<OrgMembershipWithRelations, S>[];
-        };
+        orgMembership: InferSelectResult<OrgMembershipWithRelations, S> | null;
     }>;
     findOne<S extends OrgMembershipSelect>(args: {
         id: string;

package/public/orm/models/orgMembership.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgMembershipDefaultModel {
     } & StrictSelect<S, OrgMembershipDefaultSelect>): QueryBuilder<{
         orgMembershipDefaults: ConnectionResult<InferSelectResult<OrgMembershipDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends OrgMembershipDefaultSelect>(args: FindFirstArgs<S, OrgMembershipDefaultFilter> & {
+    findFirst<S extends OrgMembershipDefaultSelect>(args: FindFirstArgs<S, OrgMembershipDefaultFilter, OrgMembershipDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMembershipDefaultSelect>): QueryBuilder<{
-        orgMembershipDefaults: {
-            nodes: InferSelectResult<OrgMembershipDefaultWithRelations, S>[];
-        };
+        orgMembershipDefault: InferSelectResult<OrgMembershipDefaultWithRelations, S> | null;
     }>;
     findOne<S extends OrgMembershipDefaultSelect>(args: {
         id: string;

package/public/orm/models/orgMembershipDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgMembershipSettingModel {
     } & StrictSelect<S, OrgMembershipSettingSelect>): QueryBuilder<{
         orgMembershipSettings: ConnectionResult<InferSelectResult<OrgMembershipSettingWithRelations, S>>;
     }>;
-    findFirst<S extends OrgMembershipSettingSelect>(args: FindFirstArgs<S, OrgMembershipSettingFilter> & {
+    findFirst<S extends OrgMembershipSettingSelect>(args: FindFirstArgs<S, OrgMembershipSettingFilter, OrgMembershipSettingOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMembershipSettingSelect>): QueryBuilder<{
-        orgMembershipSettings: {
-            nodes: InferSelectResult<OrgMembershipSettingWithRelations, S>[];
-        };
+        orgMembershipSetting: InferSelectResult<OrgMembershipSettingWithRelations, S> | null;
     }>;
     findOne<S extends OrgMembershipSettingSelect>(args: {
         id: string;

package/public/orm/models/orgMembershipSetting.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgOwnerGrantModel {
     } & StrictSelect<S, OrgOwnerGrantSelect>): QueryBuilder<{
         orgOwnerGrants: ConnectionResult<InferSelectResult<OrgOwnerGrantWithRelations, S>>;
     }>;
-    findFirst<S extends OrgOwnerGrantSelect>(args: FindFirstArgs<S, OrgOwnerGrantFilter> & {
+    findFirst<S extends OrgOwnerGrantSelect>(args: FindFirstArgs<S, OrgOwnerGrantFilter, OrgOwnerGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgOwnerGrantSelect>): QueryBuilder<{
-        orgOwnerGrants: {
-            nodes: InferSelectResult<OrgOwnerGrantWithRelations, S>[];
-        };
+        orgOwnerGrant: InferSelectResult<OrgOwnerGrantWithRelations, S> | null;
     }>;
     findOne<S extends OrgOwnerGrantSelect>(args: {
         id: string;

package/public/orm/models/orgOwnerGrant.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgPermissionModel {
     } & StrictSelect<S, OrgPermissionSelect>): QueryBuilder<{
         orgPermissions: ConnectionResult<InferSelectResult<OrgPermissionWithRelations, S>>;
     }>;
-    findFirst<S extends OrgPermissionSelect>(args: FindFirstArgs<S, OrgPermissionFilter> & {
+    findFirst<S extends OrgPermissionSelect>(args: FindFirstArgs<S, OrgPermissionFilter, OrgPermissionOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgPermissionSelect>): QueryBuilder<{
-        orgPermissions: {
-            nodes: InferSelectResult<OrgPermissionWithRelations, S>[];
-        };
+        orgPermission: InferSelectResult<OrgPermissionWithRelations, S> | null;
     }>;
     findOne<S extends OrgPermissionSelect>(args: {
         id: string;

package/public/orm/models/orgPermission.js

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

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

@@ -15,12 +15,10 @@ export declare class OrgPermissionDefaultModel {
     } & StrictSelect<S, OrgPermissionDefaultSelect>): QueryBuilder<{
         orgPermissionDefaults: ConnectionResult<InferSelectResult<OrgPermissionDefaultWithRelations, S>>;
     }>;
-    findFirst<S extends OrgPermissionDefaultSelect>(args: FindFirstArgs<S, OrgPermissionDefaultFilter> & {
+    findFirst<S extends OrgPermissionDefaultSelect>(args: FindFirstArgs<S, OrgPermissionDefaultFilter, OrgPermissionDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgPermissionDefaultSelect>): QueryBuilder<{
-        orgPermissionDefaults: {
-            nodes: InferSelectResult<OrgPermissionDefaultWithRelations, S>[];
-        };
+        orgPermissionDefault: InferSelectResult<OrgPermissionDefaultWithRelations, S> | null;
     }>;
     findOne<S extends OrgPermissionDefaultSelect>(args: {
         id: string;

package/public/orm/models/orgPermissionDefault.js

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

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

@@ -15,12 +15,10 @@ export declare class PartitionModel {
     } & StrictSelect<S, PartitionSelect>): QueryBuilder<{
         partitions: ConnectionResult<InferSelectResult<PartitionWithRelations, S>>;
     }>;
-    findFirst<S extends PartitionSelect>(args: FindFirstArgs<S, PartitionFilter> & {
+    findFirst<S extends PartitionSelect>(args: FindFirstArgs<S, PartitionFilter, PartitionOrderBy> & {
         select: S;
     } & StrictSelect<S, PartitionSelect>): QueryBuilder<{
-        partitions: {
-            nodes: InferSelectResult<PartitionWithRelations, S>[];
-        };
+        partition: InferSelectResult<PartitionWithRelations, S> | null;
     }>;
     findOne<S extends PartitionSelect>(args: {
         id: string;

package/public/orm/models/partition.js

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

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

@@ -15,12 +15,10 @@ export declare class PermissionsModuleModel {
     } & StrictSelect<S, PermissionsModuleSelect>): QueryBuilder<{
         permissionsModules: ConnectionResult<InferSelectResult<PermissionsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PermissionsModuleSelect>(args: FindFirstArgs<S, PermissionsModuleFilter> & {
+    findFirst<S extends PermissionsModuleSelect>(args: FindFirstArgs<S, PermissionsModuleFilter, PermissionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PermissionsModuleSelect>): QueryBuilder<{
-        permissionsModules: {
-            nodes: InferSelectResult<PermissionsModuleWithRelations, S>[];
-        };
+        permissionsModule: InferSelectResult<PermissionsModuleWithRelations, S> | null;
     }>;
     findOne<S extends PermissionsModuleSelect>(args: {
         id: string;