@constructive-io/sdk 0.13.1 → 0.13.3

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

@@ -10,7 +10,7 @@ import type { CryptoAuthModuleWithRelations, CryptoAuthModuleSelect, CryptoAuthM
 export declare class CryptoAuthModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends CryptoAuthModuleSelect>(args: FindManyArgs<S, CryptoAuthModuleFilter, never, CryptoAuthModuleOrderBy> & {
+    findMany<S extends CryptoAuthModuleSelect>(args: FindManyArgs<S, CryptoAuthModuleFilter, CryptoAuthModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, CryptoAuthModuleSelect>): QueryBuilder<{
         cryptoAuthModules: ConnectionResult<InferSelectResult<CryptoAuthModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DatabaseWithRelations, DatabaseSelect, DatabaseFilter, DatabaseOrd
 export declare class DatabaseModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DatabaseSelect>(args: FindManyArgs<S, DatabaseFilter, never, DatabaseOrderBy> & {
+    findMany<S extends DatabaseSelect>(args: FindManyArgs<S, DatabaseFilter, DatabaseOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseSelect>): QueryBuilder<{
         databases: ConnectionResult<InferSelectResult<DatabaseWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DatabaseProvisionModuleWithRelations, DatabaseProvisionModuleSelec
 export declare class DatabaseProvisionModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DatabaseProvisionModuleSelect>(args: FindManyArgs<S, DatabaseProvisionModuleFilter, never, DatabaseProvisionModuleOrderBy> & {
+    findMany<S extends DatabaseProvisionModuleSelect>(args: FindManyArgs<S, DatabaseProvisionModuleFilter, DatabaseProvisionModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseProvisionModuleSelect>): QueryBuilder<{
         databaseProvisionModules: ConnectionResult<InferSelectResult<DatabaseProvisionModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DatabaseTransferWithRelations, DatabaseTransferSelect, DatabaseTra
 export declare class DatabaseTransferModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DatabaseTransferSelect>(args: FindManyArgs<S, DatabaseTransferFilter, never, DatabaseTransferOrderBy> & {
+    findMany<S extends DatabaseTransferSelect>(args: FindManyArgs<S, DatabaseTransferFilter, DatabaseTransferOrderBy> & {
         select: S;
     } & StrictSelect<S, DatabaseTransferSelect>): QueryBuilder<{
         databaseTransfers: ConnectionResult<InferSelectResult<DatabaseTransferWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DefaultIdsModuleWithRelations, DefaultIdsModuleSelect, DefaultIdsM
 export declare class DefaultIdsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DefaultIdsModuleSelect>(args: FindManyArgs<S, DefaultIdsModuleFilter, never, DefaultIdsModuleOrderBy> & {
+    findMany<S extends DefaultIdsModuleSelect>(args: FindManyArgs<S, DefaultIdsModuleFilter, DefaultIdsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultIdsModuleSelect>): QueryBuilder<{
         defaultIdsModules: ConnectionResult<InferSelectResult<DefaultIdsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DefaultPrivilegeWithRelations, DefaultPrivilegeSelect, DefaultPriv
 export declare class DefaultPrivilegeModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DefaultPrivilegeSelect>(args: FindManyArgs<S, DefaultPrivilegeFilter, never, DefaultPrivilegeOrderBy> & {
+    findMany<S extends DefaultPrivilegeSelect>(args: FindManyArgs<S, DefaultPrivilegeFilter, DefaultPrivilegeOrderBy> & {
         select: S;
     } & StrictSelect<S, DefaultPrivilegeSelect>): QueryBuilder<{
         defaultPrivileges: ConnectionResult<InferSelectResult<DefaultPrivilegeWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DenormalizedTableFieldWithRelations, DenormalizedTableFieldSelect,
 export declare class DenormalizedTableFieldModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DenormalizedTableFieldSelect>(args: FindManyArgs<S, DenormalizedTableFieldFilter, never, DenormalizedTableFieldOrderBy> & {
+    findMany<S extends DenormalizedTableFieldSelect>(args: FindManyArgs<S, DenormalizedTableFieldFilter, DenormalizedTableFieldOrderBy> & {
         select: S;
     } & StrictSelect<S, DenormalizedTableFieldSelect>): QueryBuilder<{
         denormalizedTableFields: ConnectionResult<InferSelectResult<DenormalizedTableFieldWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { DomainWithRelations, DomainSelect, DomainFilter, DomainOrderBy, Cr
 export declare class DomainModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends DomainSelect>(args: FindManyArgs<S, DomainFilter, never, DomainOrderBy> & {
+    findMany<S extends DomainSelect>(args: FindManyArgs<S, DomainFilter, DomainOrderBy> & {
         select: S;
     } & StrictSelect<S, DomainSelect>): QueryBuilder<{
         domains: ConnectionResult<InferSelectResult<DomainWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { EmailWithRelations, EmailSelect, EmailFilter, EmailOrderBy, Create
 export declare class EmailModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends EmailSelect>(args: FindManyArgs<S, EmailFilter, never, EmailOrderBy> & {
+    findMany<S extends EmailSelect>(args: FindManyArgs<S, EmailFilter, EmailOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailSelect>): QueryBuilder<{
         emails: ConnectionResult<InferSelectResult<EmailWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { EmailsModuleWithRelations, EmailsModuleSelect, EmailsModuleFilter,
 export declare class EmailsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends EmailsModuleSelect>(args: FindManyArgs<S, EmailsModuleFilter, never, EmailsModuleOrderBy> & {
+    findMany<S extends EmailsModuleSelect>(args: FindManyArgs<S, EmailsModuleFilter, EmailsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EmailsModuleSelect>): QueryBuilder<{
         emailsModules: ConnectionResult<InferSelectResult<EmailsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { EmbeddingChunkWithRelations, EmbeddingChunkSelect, EmbeddingChunkF
 export declare class EmbeddingChunkModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends EmbeddingChunkSelect>(args: FindManyArgs<S, EmbeddingChunkFilter, never, EmbeddingChunkOrderBy> & {
+    findMany<S extends EmbeddingChunkSelect>(args: FindManyArgs<S, EmbeddingChunkFilter, EmbeddingChunkOrderBy> & {
         select: S;
     } & StrictSelect<S, EmbeddingChunkSelect>): QueryBuilder<{
         embeddingChunks: ConnectionResult<InferSelectResult<EmbeddingChunkWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { EncryptedSecretsModuleWithRelations, EncryptedSecretsModuleSelect,
 export declare class EncryptedSecretsModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends EncryptedSecretsModuleSelect>(args: FindManyArgs<S, EncryptedSecretsModuleFilter, never, EncryptedSecretsModuleOrderBy> & {
+    findMany<S extends EncryptedSecretsModuleSelect>(args: FindManyArgs<S, EncryptedSecretsModuleFilter, EncryptedSecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, EncryptedSecretsModuleSelect>): QueryBuilder<{
         encryptedSecretsModules: ConnectionResult<InferSelectResult<EncryptedSecretsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { EnumWithRelations, EnumSelect, EnumFilter, EnumOrderBy, CreateEnum
 export declare class EnumModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends EnumSelect>(args: FindManyArgs<S, EnumFilter, never, EnumOrderBy> & {
+    findMany<S extends EnumSelect>(args: FindManyArgs<S, EnumFilter, EnumOrderBy> & {
         select: S;
     } & StrictSelect<S, EnumSelect>): QueryBuilder<{
         enums: ConnectionResult<InferSelectResult<EnumWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { FieldWithRelations, FieldSelect, FieldFilter, FieldOrderBy, Create
 export declare class FieldModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends FieldSelect>(args: FindManyArgs<S, FieldFilter, never, FieldOrderBy> & {
+    findMany<S extends FieldSelect>(args: FindManyArgs<S, FieldFilter, FieldOrderBy> & {
         select: S;
     } & StrictSelect<S, FieldSelect>): QueryBuilder<{
         fields: ConnectionResult<InferSelectResult<FieldWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { ForeignKeyConstraintWithRelations, ForeignKeyConstraintSelect, For
 export declare class ForeignKeyConstraintModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends ForeignKeyConstraintSelect>(args: FindManyArgs<S, ForeignKeyConstraintFilter, never, ForeignKeyConstraintOrderBy> & {
+    findMany<S extends ForeignKeyConstraintSelect>(args: FindManyArgs<S, ForeignKeyConstraintFilter, ForeignKeyConstraintOrderBy> & {
         select: S;
     } & StrictSelect<S, ForeignKeyConstraintSelect>): QueryBuilder<{
         foreignKeyConstraints: ConnectionResult<InferSelectResult<ForeignKeyConstraintWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { FullTextSearchWithRelations, FullTextSearchSelect, FullTextSearchF
 export declare class FullTextSearchModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends FullTextSearchSelect>(args: FindManyArgs<S, FullTextSearchFilter, never, FullTextSearchOrderBy> & {
+    findMany<S extends FullTextSearchSelect>(args: FindManyArgs<S, FullTextSearchFilter, FullTextSearchOrderBy> & {
         select: S;
     } & StrictSelect<S, FullTextSearchSelect>): QueryBuilder<{
         fullTextSearches: ConnectionResult<InferSelectResult<FullTextSearchWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { GetAllRecordWithRelations, GetAllRecordSelect, GetAllRecordFilter,
 export declare class GetAllRecordModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends GetAllRecordSelect>(args: FindManyArgs<S, GetAllRecordFilter, never, GetAllRecordsOrderBy> & {
+    findMany<S extends GetAllRecordSelect>(args: FindManyArgs<S, GetAllRecordFilter, GetAllRecordsOrderBy> & {
         select: S;
     } & StrictSelect<S, GetAllRecordSelect>): QueryBuilder<{
         getAll: ConnectionResult<InferSelectResult<GetAllRecordWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { HierarchyModuleWithRelations, HierarchyModuleSelect, HierarchyModu
 export declare class HierarchyModuleModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends HierarchyModuleSelect>(args: FindManyArgs<S, HierarchyModuleFilter, never, HierarchyModuleOrderBy> & {
+    findMany<S extends HierarchyModuleSelect>(args: FindManyArgs<S, HierarchyModuleFilter, HierarchyModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, HierarchyModuleSelect>): QueryBuilder<{
         hierarchyModules: ConnectionResult<InferSelectResult<HierarchyModuleWithRelations, S>>;

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, never, IndexOrderBy> & {
+    findMany<S extends IndexSelect>(args: FindManyArgs<S, IndexFilter, 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, never, InviteOrderBy> & {
+    findMany<S extends InviteSelect>(args: FindManyArgs<S, InviteFilter, 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, never, InvitesModuleOrderBy> & {
+    findMany<S extends InvitesModuleSelect>(args: FindManyArgs<S, InvitesModuleFilter, 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, never, LevelsModuleOrderBy> & {
+    findMany<S extends LevelsModuleSelect>(args: FindManyArgs<S, LevelsModuleFilter, 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, never, LimitsModuleOrderBy> & {
+    findMany<S extends LimitsModuleSelect>(args: FindManyArgs<S, LimitsModuleFilter, 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, never, MembershipTypeOrderBy> & {
+    findMany<S extends MembershipTypeSelect>(args: FindManyArgs<S, MembershipTypeFilter, 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, never, MembershipTypesModuleOrderBy> & {
+    findMany<S extends MembershipTypesModuleSelect>(args: FindManyArgs<S, MembershipTypesModuleFilter, 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, never, MembershipsModuleOrderBy> & {
+    findMany<S extends MembershipsModuleSelect>(args: FindManyArgs<S, MembershipsModuleFilter, MembershipsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, MembershipsModuleSelect>): QueryBuilder<{
         membershipsModules: ConnectionResult<InferSelectResult<MembershipsModuleWithRelations, S>>;

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

@@ -10,7 +10,7 @@ import type { MigrateFileWithRelations, MigrateFileSelect, MigrateFileFilter, Mi
 export declare class MigrateFileModel {
     private client;
     constructor(client: OrmClient);
-    findMany<S extends MigrateFileSelect>(args: FindManyArgs<S, MigrateFileFilter, never, MigrateFileOrderBy> & {
+    findMany<S extends MigrateFileSelect>(args: FindManyArgs<S, MigrateFileFilter, MigrateFileOrderBy> & {
         select: S;
     } & StrictSelect<S, MigrateFileSelect>): QueryBuilder<{
         migrateFiles: ConnectionResult<InferSelectResult<MigrateFileWithRelations, 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, never, ObjectOrderBy> & {
+    findMany<S extends ObjectSelect>(args: FindManyArgs<S, ObjectFilter, 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, never, OrgAdminGrantOrderBy> & {
+    findMany<S extends OrgAdminGrantSelect>(args: FindManyArgs<S, OrgAdminGrantFilter, 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, never, OrgChartEdgeOrderBy> & {
+    findMany<S extends OrgChartEdgeSelect>(args: FindManyArgs<S, OrgChartEdgeFilter, 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, never, OrgChartEdgeGrantOrderBy> & {
+    findMany<S extends OrgChartEdgeGrantSelect>(args: FindManyArgs<S, OrgChartEdgeGrantFilter, 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, never, OrgClaimedInviteOrderBy> & {
+    findMany<S extends OrgClaimedInviteSelect>(args: FindManyArgs<S, OrgClaimedInviteFilter, 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, never, OrgGetManagersRecordsOrderBy> & {
+    findMany<S extends OrgGetManagersRecordSelect>(args: FindManyArgs<S, OrgGetManagersRecordFilter, 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, never, OrgGetSubordinatesRecordsOrderBy> & {
+    findMany<S extends OrgGetSubordinatesRecordSelect>(args: FindManyArgs<S, OrgGetSubordinatesRecordFilter, 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, never, OrgGrantOrderBy> & {
+    findMany<S extends OrgGrantSelect>(args: FindManyArgs<S, OrgGrantFilter, 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, never, OrgInviteOrderBy> & {
+    findMany<S extends OrgInviteSelect>(args: FindManyArgs<S, OrgInviteFilter, 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, never, OrgLimitOrderBy> & {
+    findMany<S extends OrgLimitSelect>(args: FindManyArgs<S, OrgLimitFilter, 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, never, OrgLimitDefaultOrderBy> & {
+    findMany<S extends OrgLimitDefaultSelect>(args: FindManyArgs<S, OrgLimitDefaultFilter, 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, never, OrgMemberOrderBy> & {
+    findMany<S extends OrgMemberSelect>(args: FindManyArgs<S, OrgMemberFilter, 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, never, OrgMembershipOrderBy> & {
+    findMany<S extends OrgMembershipSelect>(args: FindManyArgs<S, OrgMembershipFilter, 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, never, OrgMembershipDefaultOrderBy> & {
+    findMany<S extends OrgMembershipDefaultSelect>(args: FindManyArgs<S, OrgMembershipDefaultFilter, 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, never, OrgOwnerGrantOrderBy> & {
+    findMany<S extends OrgOwnerGrantSelect>(args: FindManyArgs<S, OrgOwnerGrantFilter, 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, never, OrgPermissionOrderBy> & {
+    findMany<S extends OrgPermissionSelect>(args: FindManyArgs<S, OrgPermissionFilter, 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, never, OrgPermissionDefaultOrderBy> & {
+    findMany<S extends OrgPermissionDefaultSelect>(args: FindManyArgs<S, OrgPermissionDefaultFilter, 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, never, PermissionsModuleOrderBy> & {
+    findMany<S extends PermissionsModuleSelect>(args: FindManyArgs<S, PermissionsModuleFilter, 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, never, PhoneNumberOrderBy> & {
+    findMany<S extends PhoneNumberSelect>(args: FindManyArgs<S, PhoneNumberFilter, 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, never, PhoneNumbersModuleOrderBy> & {
+    findMany<S extends PhoneNumbersModuleSelect>(args: FindManyArgs<S, PhoneNumbersModuleFilter, 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, never, PolicyOrderBy> & {
+    findMany<S extends PolicySelect>(args: FindManyArgs<S, PolicyFilter, 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, never, PrimaryKeyConstraintOrderBy> & {
+    findMany<S extends PrimaryKeyConstraintSelect>(args: FindManyArgs<S, PrimaryKeyConstraintFilter, 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, never, ProfilesModuleOrderBy> & {
+    findMany<S extends ProfilesModuleSelect>(args: FindManyArgs<S, ProfilesModuleFilter, 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, never, RefOrderBy> & {
+    findMany<S extends RefSelect>(args: FindManyArgs<S, RefFilter, 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, never, RelationProvisionOrderBy> & {
+    findMany<S extends RelationProvisionSelect>(args: FindManyArgs<S, RelationProvisionFilter, 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, never, RlsModuleOrderBy> & {
+    findMany<S extends RlsModuleSelect>(args: FindManyArgs<S, RlsModuleFilter, 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, never, RoleTypeOrderBy> & {
+    findMany<S extends RoleTypeSelect>(args: FindManyArgs<S, RoleTypeFilter, 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, never, SchemaOrderBy> & {
+    findMany<S extends SchemaSelect>(args: FindManyArgs<S, SchemaFilter, 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, never, SchemaGrantOrderBy> & {
+    findMany<S extends SchemaGrantSelect>(args: FindManyArgs<S, SchemaGrantFilter, 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, never, SecretsModuleOrderBy> & {
+    findMany<S extends SecretsModuleSelect>(args: FindManyArgs<S, SecretsModuleFilter, SecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
         secretsModules: ConnectionResult<InferSelectResult<SecretsModuleWithRelations, S>>;