@constructive-io/react 0.6.1 → 0.6.3

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

@@ -10,7 +10,7 @@ import type { IndexWithRelations, IndexSelect, IndexFilter, IndexOrderBy, Create
 export declare class IndexModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends IndexSelect>(args: FindManyArgs<S, IndexFilter, IndexOrderBy> & {
+    findMany<S extends IndexSelect>(args: FindManyArgs<S, IndexFilter, never, IndexOrderBy> & {
         select: S;
     } & StrictSelect<S, IndexSelect>): QueryBuilder<{
         indices: ConnectionResult<InferSelectResult<IndexWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { InviteWithRelations, InviteSelect, InviteFilter, InviteOrderBy, Cr
 export declare class InviteModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends InviteSelect>(args: FindManyArgs<S, InviteFilter, InviteOrderBy> & {
+    findMany<S extends InviteSelect>(args: FindManyArgs<S, InviteFilter, never, InviteOrderBy> & {
         select: S;
     } & StrictSelect<S, InviteSelect>): QueryBuilder<{
         invites: ConnectionResult<InferSelectResult<InviteWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { InvitesModuleWithRelations, InvitesModuleSelect, InvitesModuleFilt
 export declare class InvitesModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends InvitesModuleSelect>(args: FindManyArgs<S, InvitesModuleFilter, InvitesModuleOrderBy> & {
+    findMany<S extends InvitesModuleSelect>(args: FindManyArgs<S, InvitesModuleFilter, never, InvitesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, InvitesModuleSelect>): QueryBuilder<{
         invitesModules: ConnectionResult<InferSelectResult<InvitesModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { LevelsModuleWithRelations, LevelsModuleSelect, LevelsModuleFilter,
 export declare class LevelsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends LevelsModuleSelect>(args: FindManyArgs<S, LevelsModuleFilter, LevelsModuleOrderBy> & {
+    findMany<S extends LevelsModuleSelect>(args: FindManyArgs<S, LevelsModuleFilter, never, LevelsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LevelsModuleSelect>): QueryBuilder<{
         levelsModules: ConnectionResult<InferSelectResult<LevelsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { LimitsModuleWithRelations, LimitsModuleSelect, LimitsModuleFilter,
 export declare class LimitsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends LimitsModuleSelect>(args: FindManyArgs<S, LimitsModuleFilter, LimitsModuleOrderBy> & {
+    findMany<S extends LimitsModuleSelect>(args: FindManyArgs<S, LimitsModuleFilter, never, LimitsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, LimitsModuleSelect>): QueryBuilder<{
         limitsModules: ConnectionResult<InferSelectResult<LimitsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { MembershipTypeWithRelations, MembershipTypeSelect, MembershipTypeF
 export declare class MembershipTypeModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends MembershipTypeSelect>(args: FindManyArgs<S, MembershipTypeFilter, MembershipTypeOrderBy> & {
+    findMany<S extends MembershipTypeSelect>(args: FindManyArgs<S, MembershipTypeFilter, never, MembershipTypeOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypeSelect>): QueryBuilder<{
         membershipTypes: ConnectionResult<InferSelectResult<MembershipTypeWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { MembershipTypesModuleWithRelations, MembershipTypesModuleSelect, M
 export declare class MembershipTypesModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends MembershipTypesModuleSelect>(args: FindManyArgs<S, MembershipTypesModuleFilter, MembershipTypesModuleOrderBy> & {
+    findMany<S extends MembershipTypesModuleSelect>(args: FindManyArgs<S, MembershipTypesModuleFilter, never, MembershipTypesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipTypesModuleSelect>): QueryBuilder<{
         membershipTypesModules: ConnectionResult<InferSelectResult<MembershipTypesModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { MembershipsModuleWithRelations, MembershipsModuleSelect, Membershi
 export declare class MembershipsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends MembershipsModuleSelect>(args: FindManyArgs<S, MembershipsModuleFilter, MembershipsModuleOrderBy> & {
+    findMany<S extends MembershipsModuleSelect>(args: FindManyArgs<S, MembershipsModuleFilter, never, MembershipsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
         membershipsModules: ConnectionResult<InferSelectResult<MembershipsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { NodeTypeRegistryWithRelations, NodeTypeRegistrySelect, NodeTypeReg
 export declare class NodeTypeRegistryModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends NodeTypeRegistrySelect>(args: FindManyArgs<S, NodeTypeRegistryFilter, NodeTypeRegistryOrderBy> & {
+    findMany<S extends NodeTypeRegistrySelect>(args: FindManyArgs<S, NodeTypeRegistryFilter, never, NodeTypeRegistryOrderBy> & {
         select: S;
     } & StrictSelect<S, NodeTypeRegistrySelect>): QueryBuilder<{
         nodeTypeRegistries: ConnectionResult<InferSelectResult<NodeTypeRegistryWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { ObjectWithRelations, ObjectSelect, ObjectFilter, ObjectOrderBy, Cr
 export declare class ObjectModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends ObjectSelect>(args: FindManyArgs<S, ObjectFilter, ObjectOrderBy> & {
+    findMany<S extends ObjectSelect>(args: FindManyArgs<S, ObjectFilter, never, ObjectOrderBy> & {
         select: S;
     } & StrictSelect<S, ObjectSelect>): QueryBuilder<{
         objects: ConnectionResult<InferSelectResult<ObjectWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgAdminGrantWithRelations, OrgAdminGrantSelect, OrgAdminGrantFilt
 export declare class OrgAdminGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgAdminGrantSelect>(args: FindManyArgs<S, OrgAdminGrantFilter, OrgAdminGrantOrderBy> & {
+    findMany<S extends OrgAdminGrantSelect>(args: FindManyArgs<S, OrgAdminGrantFilter, never, OrgAdminGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgAdminGrantSelect>): QueryBuilder<{
         orgAdminGrants: ConnectionResult<InferSelectResult<OrgAdminGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgChartEdgeWithRelations, OrgChartEdgeSelect, OrgChartEdgeFilter,
 export declare class OrgChartEdgeModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgChartEdgeSelect>(args: FindManyArgs<S, OrgChartEdgeFilter, OrgChartEdgeOrderBy> & {
+    findMany<S extends OrgChartEdgeSelect>(args: FindManyArgs<S, OrgChartEdgeFilter, never, OrgChartEdgeOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgChartEdgeSelect>): QueryBuilder<{
         orgChartEdges: ConnectionResult<InferSelectResult<OrgChartEdgeWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgChartEdgeGrantWithRelations, OrgChartEdgeGrantSelect, OrgChartE
 export declare class OrgChartEdgeGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgChartEdgeGrantSelect>(args: FindManyArgs<S, OrgChartEdgeGrantFilter, OrgChartEdgeGrantOrderBy> & {
+    findMany<S extends OrgChartEdgeGrantSelect>(args: FindManyArgs<S, OrgChartEdgeGrantFilter, never, OrgChartEdgeGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgChartEdgeGrantSelect>): QueryBuilder<{
         orgChartEdgeGrants: ConnectionResult<InferSelectResult<OrgChartEdgeGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgClaimedInviteWithRelations, OrgClaimedInviteSelect, OrgClaimedI
 export declare class OrgClaimedInviteModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgClaimedInviteSelect>(args: FindManyArgs<S, OrgClaimedInviteFilter, OrgClaimedInviteOrderBy> & {
+    findMany<S extends OrgClaimedInviteSelect>(args: FindManyArgs<S, OrgClaimedInviteFilter, never, OrgClaimedInviteOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgClaimedInviteSelect>): QueryBuilder<{
         orgClaimedInvites: ConnectionResult<InferSelectResult<OrgClaimedInviteWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgGetManagersRecordWithRelations, OrgGetManagersRecordSelect, Org
 export declare class OrgGetManagersRecordModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgGetManagersRecordSelect>(args: FindManyArgs<S, OrgGetManagersRecordFilter, OrgGetManagersRecordsOrderBy> & {
+    findMany<S extends OrgGetManagersRecordSelect>(args: FindManyArgs<S, OrgGetManagersRecordFilter, never, OrgGetManagersRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgGetManagersRecordSelect>): QueryBuilder<{
         orgGetManagers: ConnectionResult<InferSelectResult<OrgGetManagersRecordWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgGetSubordinatesRecordWithRelations, OrgGetSubordinatesRecordSel
 export declare class OrgGetSubordinatesRecordModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgGetSubordinatesRecordSelect>(args: FindManyArgs<S, OrgGetSubordinatesRecordFilter, OrgGetSubordinatesRecordsOrderBy> & {
+    findMany<S extends OrgGetSubordinatesRecordSelect>(args: FindManyArgs<S, OrgGetSubordinatesRecordFilter, never, OrgGetSubordinatesRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgGetSubordinatesRecordSelect>): QueryBuilder<{
         orgGetSubordinates: ConnectionResult<InferSelectResult<OrgGetSubordinatesRecordWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgGrantWithRelations, OrgGrantSelect, OrgGrantFilter, OrgGrantOrd
 export declare class OrgGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgGrantSelect>(args: FindManyArgs<S, OrgGrantFilter, OrgGrantOrderBy> & {
+    findMany<S extends OrgGrantSelect>(args: FindManyArgs<S, OrgGrantFilter, never, OrgGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgGrantSelect>): QueryBuilder<{
         orgGrants: ConnectionResult<InferSelectResult<OrgGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgInviteWithRelations, OrgInviteSelect, OrgInviteFilter, OrgInvit
 export declare class OrgInviteModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgInviteSelect>(args: FindManyArgs<S, OrgInviteFilter, OrgInviteOrderBy> & {
+    findMany<S extends OrgInviteSelect>(args: FindManyArgs<S, OrgInviteFilter, never, OrgInviteOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgInviteSelect>): QueryBuilder<{
         orgInvites: ConnectionResult<InferSelectResult<OrgInviteWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgLimitWithRelations, OrgLimitSelect, OrgLimitFilter, OrgLimitOrd
 export declare class OrgLimitModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgLimitSelect>(args: FindManyArgs<S, OrgLimitFilter, OrgLimitOrderBy> & {
+    findMany<S extends OrgLimitSelect>(args: FindManyArgs<S, OrgLimitFilter, never, OrgLimitOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitSelect>): QueryBuilder<{
         orgLimits: ConnectionResult<InferSelectResult<OrgLimitWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgLimitDefaultWithRelations, OrgLimitDefaultSelect, OrgLimitDefau
 export declare class OrgLimitDefaultModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgLimitDefaultSelect>(args: FindManyArgs<S, OrgLimitDefaultFilter, OrgLimitDefaultOrderBy> & {
+    findMany<S extends OrgLimitDefaultSelect>(args: FindManyArgs<S, OrgLimitDefaultFilter, never, OrgLimitDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgLimitDefaultSelect>): QueryBuilder<{
         orgLimitDefaults: ConnectionResult<InferSelectResult<OrgLimitDefaultWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgMemberWithRelations, OrgMemberSelect, OrgMemberFilter, OrgMembe
 export declare class OrgMemberModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgMemberSelect>(args: FindManyArgs<S, OrgMemberFilter, OrgMemberOrderBy> & {
+    findMany<S extends OrgMemberSelect>(args: FindManyArgs<S, OrgMemberFilter, never, OrgMemberOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMemberSelect>): QueryBuilder<{
         orgMembers: ConnectionResult<InferSelectResult<OrgMemberWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgMembershipWithRelations, OrgMembershipSelect, OrgMembershipFilt
 export declare class OrgMembershipModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgMembershipSelect>(args: FindManyArgs<S, OrgMembershipFilter, OrgMembershipOrderBy> & {
+    findMany<S extends OrgMembershipSelect>(args: FindManyArgs<S, OrgMembershipFilter, never, OrgMembershipOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMembershipSelect>): QueryBuilder<{
         orgMemberships: ConnectionResult<InferSelectResult<OrgMembershipWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgMembershipDefaultWithRelations, OrgMembershipDefaultSelect, Org
 export declare class OrgMembershipDefaultModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgMembershipDefaultSelect>(args: FindManyArgs<S, OrgMembershipDefaultFilter, OrgMembershipDefaultOrderBy> & {
+    findMany<S extends OrgMembershipDefaultSelect>(args: FindManyArgs<S, OrgMembershipDefaultFilter, never, OrgMembershipDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgMembershipDefaultSelect>): QueryBuilder<{
         orgMembershipDefaults: ConnectionResult<InferSelectResult<OrgMembershipDefaultWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgOwnerGrantWithRelations, OrgOwnerGrantSelect, OrgOwnerGrantFilt
 export declare class OrgOwnerGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgOwnerGrantSelect>(args: FindManyArgs<S, OrgOwnerGrantFilter, OrgOwnerGrantOrderBy> & {
+    findMany<S extends OrgOwnerGrantSelect>(args: FindManyArgs<S, OrgOwnerGrantFilter, never, OrgOwnerGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgOwnerGrantSelect>): QueryBuilder<{
         orgOwnerGrants: ConnectionResult<InferSelectResult<OrgOwnerGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgPermissionWithRelations, OrgPermissionSelect, OrgPermissionFilt
 export declare class OrgPermissionModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgPermissionSelect>(args: FindManyArgs<S, OrgPermissionFilter, OrgPermissionOrderBy> & {
+    findMany<S extends OrgPermissionSelect>(args: FindManyArgs<S, OrgPermissionFilter, never, OrgPermissionOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgPermissionSelect>): QueryBuilder<{
         orgPermissions: ConnectionResult<InferSelectResult<OrgPermissionWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { OrgPermissionDefaultWithRelations, OrgPermissionDefaultSelect, Org
 export declare class OrgPermissionDefaultModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends OrgPermissionDefaultSelect>(args: FindManyArgs<S, OrgPermissionDefaultFilter, OrgPermissionDefaultOrderBy> & {
+    findMany<S extends OrgPermissionDefaultSelect>(args: FindManyArgs<S, OrgPermissionDefaultFilter, never, OrgPermissionDefaultOrderBy> & {
         select: S;
     } & StrictSelect<S, OrgPermissionDefaultSelect>): QueryBuilder<{
         orgPermissionDefaults: ConnectionResult<InferSelectResult<OrgPermissionDefaultWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { PermissionsModuleWithRelations, PermissionsModuleSelect, Permissio
 export declare class PermissionsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends PermissionsModuleSelect>(args: FindManyArgs<S, PermissionsModuleFilter, PermissionsModuleOrderBy> & {
+    findMany<S extends PermissionsModuleSelect>(args: FindManyArgs<S, PermissionsModuleFilter, never, PermissionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PermissionsModuleSelect>): QueryBuilder<{
         permissionsModules: ConnectionResult<InferSelectResult<PermissionsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { PhoneNumberWithRelations, PhoneNumberSelect, PhoneNumberFilter, Ph
 export declare class PhoneNumberModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends PhoneNumberSelect>(args: FindManyArgs<S, PhoneNumberFilter, PhoneNumberOrderBy> & {
+    findMany<S extends PhoneNumberSelect>(args: FindManyArgs<S, PhoneNumberFilter, never, PhoneNumberOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumberSelect>): QueryBuilder<{
         phoneNumbers: ConnectionResult<InferSelectResult<PhoneNumberWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { PhoneNumbersModuleWithRelations, PhoneNumbersModuleSelect, PhoneNu
 export declare class PhoneNumbersModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends PhoneNumbersModuleSelect>(args: FindManyArgs<S, PhoneNumbersModuleFilter, PhoneNumbersModuleOrderBy> & {
+    findMany<S extends PhoneNumbersModuleSelect>(args: FindManyArgs<S, PhoneNumbersModuleFilter, never, PhoneNumbersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, PhoneNumbersModuleSelect>): QueryBuilder<{
         phoneNumbersModules: ConnectionResult<InferSelectResult<PhoneNumbersModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { PolicyWithRelations, PolicySelect, PolicyFilter, PolicyOrderBy, Cr
 export declare class PolicyModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends PolicySelect>(args: FindManyArgs<S, PolicyFilter, PolicyOrderBy> & {
+    findMany<S extends PolicySelect>(args: FindManyArgs<S, PolicyFilter, never, PolicyOrderBy> & {
         select: S;
     } & StrictSelect<S, PolicySelect>): QueryBuilder<{
         policies: ConnectionResult<InferSelectResult<PolicyWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { PrimaryKeyConstraintWithRelations, PrimaryKeyConstraintSelect, Pri
 export declare class PrimaryKeyConstraintModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends PrimaryKeyConstraintSelect>(args: FindManyArgs<S, PrimaryKeyConstraintFilter, PrimaryKeyConstraintOrderBy> & {
+    findMany<S extends PrimaryKeyConstraintSelect>(args: FindManyArgs<S, PrimaryKeyConstraintFilter, never, PrimaryKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, PrimaryKeyConstraintSelect>): QueryBuilder<{
         primaryKeyConstraints: ConnectionResult<InferSelectResult<PrimaryKeyConstraintWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { ProfilesModuleWithRelations, ProfilesModuleSelect, ProfilesModuleF
 export declare class ProfilesModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends ProfilesModuleSelect>(args: FindManyArgs<S, ProfilesModuleFilter, ProfilesModuleOrderBy> & {
+    findMany<S extends ProfilesModuleSelect>(args: FindManyArgs<S, ProfilesModuleFilter, never, ProfilesModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, ProfilesModuleSelect>): QueryBuilder<{
         profilesModules: ConnectionResult<InferSelectResult<ProfilesModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { RefWithRelations, RefSelect, RefFilter, RefOrderBy, CreateRefInput
 export declare class RefModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends RefSelect>(args: FindManyArgs<S, RefFilter, RefOrderBy> & {
+    findMany<S extends RefSelect>(args: FindManyArgs<S, RefFilter, never, RefOrderBy> & {
         select: S;
     } & StrictSelect<S, RefSelect>): QueryBuilder<{
         refs: ConnectionResult<InferSelectResult<RefWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { RelationProvisionWithRelations, RelationProvisionSelect, RelationP
 export declare class RelationProvisionModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends RelationProvisionSelect>(args: FindManyArgs<S, RelationProvisionFilter, RelationProvisionOrderBy> & {
+    findMany<S extends RelationProvisionSelect>(args: FindManyArgs<S, RelationProvisionFilter, never, RelationProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, RelationProvisionSelect>): QueryBuilder<{
         relationProvisions: ConnectionResult<InferSelectResult<RelationProvisionWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { RlsModuleWithRelations, RlsModuleSelect, RlsModuleFilter, RlsModul
 export declare class RlsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends RlsModuleSelect>(args: FindManyArgs<S, RlsModuleFilter, RlsModuleOrderBy> & {
+    findMany<S extends RlsModuleSelect>(args: FindManyArgs<S, RlsModuleFilter, never, RlsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, RlsModuleSelect>): QueryBuilder<{
         rlsModules: ConnectionResult<InferSelectResult<RlsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { RoleTypeWithRelations, RoleTypeSelect, RoleTypeFilter, RoleTypeOrd
 export declare class RoleTypeModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends RoleTypeSelect>(args: FindManyArgs<S, RoleTypeFilter, RoleTypeOrderBy> & {
+    findMany<S extends RoleTypeSelect>(args: FindManyArgs<S, RoleTypeFilter, never, RoleTypeOrderBy> & {
         select: S;
     } & StrictSelect<S, RoleTypeSelect>): QueryBuilder<{
         roleTypes: ConnectionResult<InferSelectResult<RoleTypeWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SchemaWithRelations, SchemaSelect, SchemaFilter, SchemaOrderBy, Cr
 export declare class SchemaModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SchemaSelect>(args: FindManyArgs<S, SchemaFilter, SchemaOrderBy> & {
+    findMany<S extends SchemaSelect>(args: FindManyArgs<S, SchemaFilter, never, SchemaOrderBy> & {
         select: S;
     } & StrictSelect<S, SchemaSelect>): QueryBuilder<{
         schemas: ConnectionResult<InferSelectResult<SchemaWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SchemaGrantWithRelations, SchemaGrantSelect, SchemaGrantFilter, Sc
 export declare class SchemaGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SchemaGrantSelect>(args: FindManyArgs<S, SchemaGrantFilter, SchemaGrantOrderBy> & {
+    findMany<S extends SchemaGrantSelect>(args: FindManyArgs<S, SchemaGrantFilter, never, SchemaGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, SchemaGrantSelect>): QueryBuilder<{
         schemaGrants: ConnectionResult<InferSelectResult<SchemaGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SecretsModuleWithRelations, SecretsModuleSelect, SecretsModuleFilt
 export declare class SecretsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SecretsModuleSelect>(args: FindManyArgs<S, SecretsModuleFilter, SecretsModuleOrderBy> & {
+    findMany<S extends SecretsModuleSelect>(args: FindManyArgs<S, SecretsModuleFilter, never, SecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
         secretsModules: ConnectionResult<InferSelectResult<SecretsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SecureTableProvisionWithRelations, SecureTableProvisionSelect, Sec
 export declare class SecureTableProvisionModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SecureTableProvisionSelect>(args: FindManyArgs<S, SecureTableProvisionFilter, SecureTableProvisionOrderBy> & {
+    findMany<S extends SecureTableProvisionSelect>(args: FindManyArgs<S, SecureTableProvisionFilter, never, SecureTableProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, SecureTableProvisionSelect>): QueryBuilder<{
         secureTableProvisions: ConnectionResult<InferSelectResult<SecureTableProvisionWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SessionsModuleWithRelations, SessionsModuleSelect, SessionsModuleF
 export declare class SessionsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SessionsModuleSelect>(args: FindManyArgs<S, SessionsModuleFilter, SessionsModuleOrderBy> & {
+    findMany<S extends SessionsModuleSelect>(args: FindManyArgs<S, SessionsModuleFilter, never, SessionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SessionsModuleSelect>): QueryBuilder<{
         sessionsModules: ConnectionResult<InferSelectResult<SessionsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SiteWithRelations, SiteSelect, SiteFilter, SiteOrderBy, CreateSite
 export declare class SiteModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SiteSelect>(args: FindManyArgs<S, SiteFilter, SiteOrderBy> & {
+    findMany<S extends SiteSelect>(args: FindManyArgs<S, SiteFilter, never, SiteOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteSelect>): QueryBuilder<{
         sites: ConnectionResult<InferSelectResult<SiteWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SiteMetadatumWithRelations, SiteMetadatumSelect, SiteMetadatumFilt
 export declare class SiteMetadatumModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SiteMetadatumSelect>(args: FindManyArgs<S, SiteMetadatumFilter, SiteMetadatumOrderBy> & {
+    findMany<S extends SiteMetadatumSelect>(args: FindManyArgs<S, SiteMetadatumFilter, never, SiteMetadatumOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
         siteMetadata: ConnectionResult<InferSelectResult<SiteMetadatumWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SiteModuleWithRelations, SiteModuleSelect, SiteModuleFilter, SiteM
 export declare class SiteModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SiteModuleSelect>(args: FindManyArgs<S, SiteModuleFilter, SiteModuleOrderBy> & {
+    findMany<S extends SiteModuleSelect>(args: FindManyArgs<S, SiteModuleFilter, never, SiteModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
         siteModules: ConnectionResult<InferSelectResult<SiteModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SiteThemeWithRelations, SiteThemeSelect, SiteThemeFilter, SiteThem
 export declare class SiteThemeModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SiteThemeSelect>(args: FindManyArgs<S, SiteThemeFilter, SiteThemeOrderBy> & {
+    findMany<S extends SiteThemeSelect>(args: FindManyArgs<S, SiteThemeFilter, never, SiteThemeOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
         siteThemes: ConnectionResult<InferSelectResult<SiteThemeWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { SqlMigrationWithRelations, SqlMigrationSelect, SqlMigrationFilter,
 export declare class SqlMigrationModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends SqlMigrationSelect>(args: FindManyArgs<S, SqlMigrationFilter, SqlMigrationOrderBy> & {
+    findMany<S extends SqlMigrationSelect>(args: FindManyArgs<S, SqlMigrationFilter, never, SqlMigrationOrderBy> & {
         select: S;
     } & StrictSelect<S, SqlMigrationSelect>): QueryBuilder<{
         sqlMigrations: ConnectionResult<InferSelectResult<SqlMigrationWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { StoreWithRelations, StoreSelect, StoreFilter, StoreOrderBy, Create
 export declare class StoreModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends StoreSelect>(args: FindManyArgs<S, StoreFilter, StoreOrderBy> & {
+    findMany<S extends StoreSelect>(args: FindManyArgs<S, StoreFilter, never, StoreOrderBy> & {
         select: S;
     } & StrictSelect<S, StoreSelect>): QueryBuilder<{
         stores: ConnectionResult<InferSelectResult<StoreWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { TableWithRelations, TableSelect, TableFilter, TableOrderBy, Create
 export declare class TableModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends TableSelect>(args: FindManyArgs<S, TableFilter, TableOrderBy> & {
+    findMany<S extends TableSelect>(args: FindManyArgs<S, TableFilter, never, TableOrderBy> & {
         select: S;
     } & StrictSelect<S, TableSelect>): QueryBuilder<{
         tables: ConnectionResult<InferSelectResult<TableWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { TableGrantWithRelations, TableGrantSelect, TableGrantFilter, Table
 export declare class TableGrantModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends TableGrantSelect>(args: FindManyArgs<S, TableGrantFilter, TableGrantOrderBy> & {
+    findMany<S extends TableGrantSelect>(args: FindManyArgs<S, TableGrantFilter, never, TableGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, TableGrantSelect>): QueryBuilder<{
         tableGrants: ConnectionResult<InferSelectResult<TableGrantWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { TableTemplateModuleWithRelations, TableTemplateModuleSelect, Table
 export declare class TableTemplateModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends TableTemplateModuleSelect>(args: FindManyArgs<S, TableTemplateModuleFilter, TableTemplateModuleOrderBy> & {
+    findMany<S extends TableTemplateModuleSelect>(args: FindManyArgs<S, TableTemplateModuleFilter, never, TableTemplateModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, TableTemplateModuleSelect>): QueryBuilder<{
         tableTemplateModules: ConnectionResult<InferSelectResult<TableTemplateModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { TriggerWithRelations, TriggerSelect, TriggerFilter, TriggerOrderBy
 export declare class TriggerModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends TriggerSelect>(args: FindManyArgs<S, TriggerFilter, TriggerOrderBy> & {
+    findMany<S extends TriggerSelect>(args: FindManyArgs<S, TriggerFilter, never, TriggerOrderBy> & {
         select: S;
     } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
         triggers: ConnectionResult<InferSelectResult<TriggerWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { TriggerFunctionWithRelations, TriggerFunctionSelect, TriggerFuncti
 export declare class TriggerFunctionModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends TriggerFunctionSelect>(args: FindManyArgs<S, TriggerFunctionFilter, TriggerFunctionOrderBy> & {
+    findMany<S extends TriggerFunctionSelect>(args: FindManyArgs<S, TriggerFunctionFilter, never, TriggerFunctionOrderBy> & {
         select: S;
     } & StrictSelect<S, TriggerFunctionSelect>): QueryBuilder<{
         triggerFunctions: ConnectionResult<InferSelectResult<TriggerFunctionWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { UniqueConstraintWithRelations, UniqueConstraintSelect, UniqueConst
 export declare class UniqueConstraintModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends UniqueConstraintSelect>(args: FindManyArgs<S, UniqueConstraintFilter, UniqueConstraintOrderBy> & {
+    findMany<S extends UniqueConstraintSelect>(args: FindManyArgs<S, UniqueConstraintFilter, never, UniqueConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, UniqueConstraintSelect>): QueryBuilder<{
         uniqueConstraints: ConnectionResult<InferSelectResult<UniqueConstraintWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { UserWithRelations, UserSelect, UserFilter, UserOrderBy, CreateUser
 export declare class UserModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends UserSelect>(args: FindManyArgs<S, UserFilter, UserOrderBy> & {
+    findMany<S extends UserSelect>(args: FindManyArgs<S, UserFilter, never, UserOrderBy> & {
         select: S;
     } & StrictSelect<S, UserSelect>): QueryBuilder<{
         users: ConnectionResult<InferSelectResult<UserWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { UserAuthModuleWithRelations, UserAuthModuleSelect, UserAuthModuleF
 export declare class UserAuthModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends UserAuthModuleSelect>(args: FindManyArgs<S, UserAuthModuleFilter, UserAuthModuleOrderBy> & {
+    findMany<S extends UserAuthModuleSelect>(args: FindManyArgs<S, UserAuthModuleFilter, never, UserAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, UserAuthModuleSelect>): QueryBuilder<{
         userAuthModules: ConnectionResult<InferSelectResult<UserAuthModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { UsersModuleWithRelations, UsersModuleSelect, UsersModuleFilter, Us
 export declare class UsersModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends UsersModuleSelect>(args: FindManyArgs<S, UsersModuleFilter, UsersModuleOrderBy> & {
+    findMany<S extends UsersModuleSelect>(args: FindManyArgs<S, UsersModuleFilter, never, UsersModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, UsersModuleSelect>): QueryBuilder<{
         usersModules: ConnectionResult<InferSelectResult<UsersModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { UuidModuleWithRelations, UuidModuleSelect, UuidModuleFilter, UuidM
 export declare class UuidModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends UuidModuleSelect>(args: FindManyArgs<S, UuidModuleFilter, UuidModuleOrderBy> & {
+    findMany<S extends UuidModuleSelect>(args: FindManyArgs<S, UuidModuleFilter, never, UuidModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, UuidModuleSelect>): QueryBuilder<{
         uuidModules: ConnectionResult<InferSelectResult<UuidModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { ViewWithRelations, ViewSelect, ViewFilter, ViewOrderBy, CreateView
 export declare class ViewModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends ViewSelect>(args: FindManyArgs<S, ViewFilter, ViewOrderBy> & {
+    findMany<S extends ViewSelect>(args: FindManyArgs<S, ViewFilter, never, ViewOrderBy> & {
         select: S;
     } & StrictSelect<S, ViewSelect>): QueryBuilder<{
         views: ConnectionResult<InferSelectResult<ViewWithRelations, S>>;