@constructive-io/sdk 0.21.5 → 0.21.7

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

@@ -27,14 +27,18 @@ export class OrgLimitDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgLimitDefault', 'orgLimitDefaults', args.select, {
             where: args?.where,
-        }, 'OrgLimitDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgLimitDefaultFilter', 'OrgLimitDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgLimitEvent.js

@@ -27,14 +27,18 @@ export class OrgLimitEventModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgLimitEvent', 'orgLimitEvents', args.select, {
             where: args?.where,
-        }, 'OrgLimitEventFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgLimitEventFilter', 'OrgLimitEventOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgMember.js

@@ -27,14 +27,18 @@ export class OrgMemberModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgMember', 'orgMembers', args.select, {
             where: args?.where,
-        }, 'OrgMemberFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgMemberFilter', 'OrgMemberOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgMemberProfile.js

@@ -27,14 +27,18 @@ export class OrgMemberProfileModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgMemberProfile', 'orgMemberProfiles', args.select, {
             where: args?.where,
-        }, 'OrgMemberProfileFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgMemberProfileFilter', 'OrgMemberProfileOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgMembership.js

@@ -27,14 +27,18 @@ export class OrgMembershipModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgMembership', 'orgMemberships', args.select, {
             where: args?.where,
-        }, 'OrgMembershipFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgMembershipFilter', 'OrgMembershipOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgMembershipDefault.js

@@ -27,14 +27,18 @@ export class OrgMembershipDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgMembershipDefault', 'orgMembershipDefaults', args.select, {
             where: args?.where,
-        }, 'OrgMembershipDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgMembershipDefaultFilter', 'OrgMembershipDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgMembershipSetting.js

@@ -27,14 +27,18 @@ export class OrgMembershipSettingModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgMembershipSetting', 'orgMembershipSettings', args.select, {
             where: args?.where,
-        }, 'OrgMembershipSettingFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgMembershipSettingFilter', 'OrgMembershipSettingOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgOwnerGrant.js

@@ -27,14 +27,18 @@ export class OrgOwnerGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgOwnerGrant', 'orgOwnerGrants', args.select, {
             where: args?.where,
-        }, 'OrgOwnerGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgOwnerGrantFilter', 'OrgOwnerGrantOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgPermission.js

@@ -27,14 +27,18 @@ export class OrgPermissionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgPermission', 'orgPermissions', args.select, {
             where: args?.where,
-        }, 'OrgPermissionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgPermissionFilter', 'OrgPermissionOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/orgPermissionDefault.js

@@ -27,14 +27,18 @@ export class OrgPermissionDefaultModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('OrgPermissionDefault', 'orgPermissionDefaults', args.select, {
             where: args?.where,
-        }, 'OrgPermissionDefaultFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'OrgPermissionDefaultFilter', 'OrgPermissionDefaultOrderBy', connectionFieldsMap);
         return new 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/esm/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/esm/public/orm/models/partition.js

@@ -27,14 +27,18 @@ export class PartitionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Partition', 'partitions', args.select, {
             where: args?.where,
-        }, 'PartitionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PartitionFilter', 'PartitionOrderBy', connectionFieldsMap);
         return new 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/esm/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;

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

@@ -27,14 +27,18 @@ export class PermissionsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PermissionsModule', 'permissionsModules', args.select, {
             where: args?.where,
-        }, 'PermissionsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PermissionsModuleFilter', 'PermissionsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PermissionsModule',
-            fieldName: 'permissionsModules',
+            fieldName: 'permissionsModule',
             document,
             variables,
+            transform: (data) => ({
+                permissionsModule: data.permissionsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PhoneNumberModel {
     } & StrictSelect<S, PhoneNumberSelect>): QueryBuilder<{
         phoneNumbers: ConnectionResult<InferSelectResult<PhoneNumberWithRelations, S>>;
     }>;
-    findFirst<S extends PhoneNumberSelect>(args: FindFirstArgs<S, PhoneNumberFilter> & {
+    findFirst<S extends PhoneNumberSelect>(args: FindFirstArgs<S, PhoneNumberFilter, PhoneNumberOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumberSelect>): QueryBuilder<{
-        phoneNumbers: {
-            nodes: InferSelectResult<PhoneNumberWithRelations, S>[];
-        };
+        phoneNumber: InferSelectResult<PhoneNumberWithRelations, S> | null;
     }>;
     findOne<S extends PhoneNumberSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PhoneNumberModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PhoneNumber', 'phoneNumbers', args.select, {
             where: args?.where,
-        }, 'PhoneNumberFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PhoneNumberFilter', 'PhoneNumberOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PhoneNumber',
-            fieldName: 'phoneNumbers',
+            fieldName: 'phoneNumber',
             document,
             variables,
+            transform: (data) => ({
+                phoneNumber: data.phoneNumbers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PhoneNumbersModuleModel {
     } & StrictSelect<S, PhoneNumbersModuleSelect>): QueryBuilder<{
         phoneNumbersModules: ConnectionResult<InferSelectResult<PhoneNumbersModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PhoneNumbersModuleSelect>(args: FindFirstArgs<S, PhoneNumbersModuleFilter> & {
+    findFirst<S extends PhoneNumbersModuleSelect>(args: FindFirstArgs<S, PhoneNumbersModuleFilter, PhoneNumbersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumbersModuleSelect>): QueryBuilder<{
-        phoneNumbersModules: {
-            nodes: InferSelectResult<PhoneNumbersModuleWithRelations, S>[];
-        };
+        phoneNumbersModule: InferSelectResult<PhoneNumbersModuleWithRelations, S> | null;
     }>;
     findOne<S extends PhoneNumbersModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PhoneNumbersModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PhoneNumbersModule', 'phoneNumbersModules', args.select, {
             where: args?.where,
-        }, 'PhoneNumbersModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PhoneNumbersModuleFilter', 'PhoneNumbersModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PhoneNumbersModule',
-            fieldName: 'phoneNumbersModules',
+            fieldName: 'phoneNumbersModule',
             document,
             variables,
+            transform: (data) => ({
+                phoneNumbersModule: data.phoneNumbersModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PlansModuleModel {
     } & StrictSelect<S, PlansModuleSelect>): QueryBuilder<{
         plansModules: ConnectionResult<InferSelectResult<PlansModuleWithRelations, S>>;
     }>;
-    findFirst<S extends PlansModuleSelect>(args: FindFirstArgs<S, PlansModuleFilter> & {
+    findFirst<S extends PlansModuleSelect>(args: FindFirstArgs<S, PlansModuleFilter, PlansModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PlansModuleSelect>): QueryBuilder<{
-        plansModules: {
-            nodes: InferSelectResult<PlansModuleWithRelations, S>[];
-        };
+        plansModule: InferSelectResult<PlansModuleWithRelations, S> | null;
     }>;
     findOne<S extends PlansModuleSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PlansModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PlansModule', 'plansModules', args.select, {
             where: args?.where,
-        }, 'PlansModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PlansModuleFilter', 'PlansModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PlansModule',
-            fieldName: 'plansModules',
+            fieldName: 'plansModule',
             document,
             variables,
+            transform: (data) => ({
+                plansModule: data.plansModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PolicyModel {
     } & StrictSelect<S, PolicySelect>): QueryBuilder<{
         policies: ConnectionResult<InferSelectResult<PolicyWithRelations, S>>;
     }>;
-    findFirst<S extends PolicySelect>(args: FindFirstArgs<S, PolicyFilter> & {
+    findFirst<S extends PolicySelect>(args: FindFirstArgs<S, PolicyFilter, PolicyOrderBy> & {
         select: S;
     } & StrictSelect<S, PolicySelect>): QueryBuilder<{
-        policies: {
-            nodes: InferSelectResult<PolicyWithRelations, S>[];
-        };
+        policy: InferSelectResult<PolicyWithRelations, S> | null;
     }>;
     findOne<S extends PolicySelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PolicyModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Policy', 'policies', args.select, {
             where: args?.where,
-        }, 'PolicyFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PolicyFilter', 'PolicyOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Policy',
-            fieldName: 'policies',
+            fieldName: 'policy',
             document,
             variables,
+            transform: (data) => ({
+                policy: data.policies?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

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

@@ -15,12 +15,10 @@ export declare class PrimaryKeyConstraintModel {
     } & StrictSelect<S, PrimaryKeyConstraintSelect>): QueryBuilder<{
         primaryKeyConstraints: ConnectionResult<InferSelectResult<PrimaryKeyConstraintWithRelations, S>>;
     }>;
-    findFirst<S extends PrimaryKeyConstraintSelect>(args: FindFirstArgs<S, PrimaryKeyConstraintFilter> & {
+    findFirst<S extends PrimaryKeyConstraintSelect>(args: FindFirstArgs<S, PrimaryKeyConstraintFilter, PrimaryKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, PrimaryKeyConstraintSelect>): QueryBuilder<{
-        primaryKeyConstraints: {
-            nodes: InferSelectResult<PrimaryKeyConstraintWithRelations, S>[];
-        };
+        primaryKeyConstraint: InferSelectResult<PrimaryKeyConstraintWithRelations, S> | null;
     }>;
     findOne<S extends PrimaryKeyConstraintSelect>(args: {
         id: string;

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

@@ -27,14 +27,18 @@ export class PrimaryKeyConstraintModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('PrimaryKeyConstraint', 'primaryKeyConstraints', args.select, {
             where: args?.where,
-        }, 'PrimaryKeyConstraintFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'PrimaryKeyConstraintFilter', 'PrimaryKeyConstraintOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'PrimaryKeyConstraint',
-            fieldName: 'primaryKeyConstraints',
+            fieldName: 'primaryKeyConstraint',
             document,
             variables,
+            transform: (data) => ({
+                primaryKeyConstraint: data.primaryKeyConstraints?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {