@constructive-sdk/cli 0.14.0 → 0.14.2

package/esm/{auth/orm/models/connectedAccount.js → public/orm/models/orgMemberProfile.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class ConnectedAccountModel {
+export class OrgMemberProfileModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('ConnectedAccount', 'connectedAccounts', args.select, {
+        const { document, variables } = buildFindManyDocument('OrgMemberProfile', 'orgMemberProfiles', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,81 +14,81 @@ export class ConnectedAccountModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'ConnectedAccountFilter', 'ConnectedAccountOrderBy', connectionFieldsMap);
+        }, 'OrgMemberProfileFilter', 'OrgMemberProfileOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'ConnectedAccount',
-            fieldName: 'connectedAccounts',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'orgMemberProfiles',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('ConnectedAccount', 'connectedAccounts', args.select, {
+        const { document, variables } = buildFindFirstDocument('OrgMemberProfile', 'orgMemberProfiles', args.select, {
             where: args?.where,
-        }, 'ConnectedAccountFilter', connectionFieldsMap);
+        }, 'OrgMemberProfileFilter', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'ConnectedAccount',
-            fieldName: 'connectedAccounts',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'orgMemberProfiles',
             document,
             variables,
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('ConnectedAccount', 'connectedAccounts', args.select, {
+        const { document, variables } = buildFindManyDocument('OrgMemberProfile', 'orgMemberProfiles', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'ConnectedAccountFilter', 'ConnectedAccountOrderBy', connectionFieldsMap);
+        }, 'OrgMemberProfileFilter', 'OrgMemberProfileOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'ConnectedAccount',
-            fieldName: 'connectedAccount',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'orgMemberProfile',
             document,
             variables,
             transform: (data) => ({
-                connectedAccount: data.connectedAccounts?.nodes?.[0] ?? null,
+                orgMemberProfile: data.orgMemberProfiles?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('ConnectedAccount', 'createConnectedAccount', 'connectedAccount', args.select, args.data, 'CreateConnectedAccountInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('OrgMemberProfile', 'createOrgMemberProfile', 'orgMemberProfile', args.select, args.data, 'CreateOrgMemberProfileInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'ConnectedAccount',
-            fieldName: 'createConnectedAccount',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'createOrgMemberProfile',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('ConnectedAccount', 'updateConnectedAccount', 'connectedAccount', args.select, args.where.id, args.data, 'UpdateConnectedAccountInput', 'id', 'connectedAccountPatch', connectionFieldsMap);
+        const { document, variables } = buildUpdateByPkDocument('OrgMemberProfile', 'updateOrgMemberProfile', 'orgMemberProfile', args.select, args.where.id, args.data, 'UpdateOrgMemberProfileInput', 'id', 'orgMemberProfilePatch', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'ConnectedAccount',
-            fieldName: 'updateConnectedAccount',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'updateOrgMemberProfile',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('ConnectedAccount', 'deleteConnectedAccount', 'connectedAccount', {
+        const { document, variables } = buildDeleteByPkDocument('OrgMemberProfile', 'deleteOrgMemberProfile', 'orgMemberProfile', {
             id: args.where.id,
-        }, 'DeleteConnectedAccountInput', args.select, connectionFieldsMap);
+        }, 'DeleteOrgMemberProfileInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'ConnectedAccount',
-            fieldName: 'deleteConnectedAccount',
+            operationName: 'OrgMemberProfile',
+            fieldName: 'deleteOrgMemberProfile',
             document,
             variables,
         });

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

@@ -0,0 +1,56 @@
+/**
+ * SessionSecretsModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { SessionSecretsModuleWithRelations, SessionSecretsModuleSelect, SessionSecretsModuleFilter, SessionSecretsModuleOrderBy, CreateSessionSecretsModuleInput, SessionSecretsModulePatch } from '../input-types';
+export declare class SessionSecretsModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends SessionSecretsModuleSelect>(args: FindManyArgs<S, SessionSecretsModuleFilter, SessionSecretsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        sessionSecretsModules: ConnectionResult<InferSelectResult<SessionSecretsModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends SessionSecretsModuleSelect>(args: FindFirstArgs<S, SessionSecretsModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        sessionSecretsModules: {
+            nodes: InferSelectResult<SessionSecretsModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends SessionSecretsModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S> | null;
+    }>;
+    create<S extends SessionSecretsModuleSelect>(args: CreateArgs<S, CreateSessionSecretsModuleInput['sessionSecretsModule']> & {
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        createSessionSecretsModule: {
+            sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends SessionSecretsModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, SessionSecretsModulePatch> & {
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        updateSessionSecretsModule: {
+            sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends SessionSecretsModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
+        deleteSessionSecretsModule: {
+            sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S>;
+        };
+    }>;
+}

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

@@ -0,0 +1,96 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class SessionSecretsModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('SessionSecretsModule', 'sessionSecretsModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'SessionSecretsModuleFilter', 'SessionSecretsModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'sessionSecretsModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('SessionSecretsModule', 'sessionSecretsModules', args.select, {
+            where: args?.where,
+        }, 'SessionSecretsModuleFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'sessionSecretsModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('SessionSecretsModule', 'sessionSecretsModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'SessionSecretsModuleFilter', 'SessionSecretsModuleOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'sessionSecretsModule',
+            document,
+            variables,
+            transform: (data) => ({
+                sessionSecretsModule: data.sessionSecretsModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('SessionSecretsModule', 'createSessionSecretsModule', 'sessionSecretsModule', args.select, args.data, 'CreateSessionSecretsModuleInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'createSessionSecretsModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('SessionSecretsModule', 'updateSessionSecretsModule', 'sessionSecretsModule', args.select, args.where.id, args.data, 'UpdateSessionSecretsModuleInput', 'id', 'sessionSecretsModulePatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'updateSessionSecretsModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('SessionSecretsModule', 'deleteSessionSecretsModule', 'sessionSecretsModule', {
+            id: args.where.id,
+        }, 'DeleteSessionSecretsModuleInput', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SessionSecretsModule',
+            fieldName: 'deleteSessionSecretsModule',
+            document,
+            variables,
+        });
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * SpatialRelation model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { SpatialRelationWithRelations, SpatialRelationSelect, SpatialRelationFilter, SpatialRelationOrderBy, CreateSpatialRelationInput, SpatialRelationPatch } from '../input-types';
+export declare class SpatialRelationModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends SpatialRelationSelect>(args: FindManyArgs<S, SpatialRelationFilter, SpatialRelationOrderBy> & {
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        spatialRelations: ConnectionResult<InferSelectResult<SpatialRelationWithRelations, S>>;
+    }>;
+    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter> & {
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        spatialRelations: {
+            nodes: InferSelectResult<SpatialRelationWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends SpatialRelationSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        spatialRelation: InferSelectResult<SpatialRelationWithRelations, S> | null;
+    }>;
+    create<S extends SpatialRelationSelect>(args: CreateArgs<S, CreateSpatialRelationInput['spatialRelation']> & {
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        createSpatialRelation: {
+            spatialRelation: InferSelectResult<SpatialRelationWithRelations, S>;
+        };
+    }>;
+    update<S extends SpatialRelationSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, SpatialRelationPatch> & {
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        updateSpatialRelation: {
+            spatialRelation: InferSelectResult<SpatialRelationWithRelations, S>;
+        };
+    }>;
+    delete<S extends SpatialRelationSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
+        deleteSpatialRelation: {
+            spatialRelation: InferSelectResult<SpatialRelationWithRelations, S>;
+        };
+    }>;
+}

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

@@ -0,0 +1,96 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class SpatialRelationModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('SpatialRelation', 'spatialRelations', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'SpatialRelationFilter', 'SpatialRelationOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SpatialRelation',
+            fieldName: 'spatialRelations',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('SpatialRelation', 'spatialRelations', args.select, {
+            where: args?.where,
+        }, 'SpatialRelationFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SpatialRelation',
+            fieldName: 'spatialRelations',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('SpatialRelation', 'spatialRelations', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'SpatialRelationFilter', 'SpatialRelationOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'SpatialRelation',
+            fieldName: 'spatialRelation',
+            document,
+            variables,
+            transform: (data) => ({
+                spatialRelation: data.spatialRelations?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('SpatialRelation', 'createSpatialRelation', 'spatialRelation', args.select, args.data, 'CreateSpatialRelationInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SpatialRelation',
+            fieldName: 'createSpatialRelation',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('SpatialRelation', 'updateSpatialRelation', 'spatialRelation', args.select, args.where.id, args.data, 'UpdateSpatialRelationInput', 'id', 'spatialRelationPatch', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SpatialRelation',
+            fieldName: 'updateSpatialRelation',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('SpatialRelation', 'deleteSpatialRelation', 'spatialRelation', {
+            id: args.where.id,
+        }, 'DeleteSpatialRelationInput', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'SpatialRelation',
+            fieldName: 'deleteSpatialRelation',
+            document,
+            variables,
+        });
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * UserConnectedAccount model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { UserConnectedAccountWithRelations, UserConnectedAccountSelect, UserConnectedAccountFilter, UserConnectedAccountOrderBy, CreateUserConnectedAccountInput } from '../input-types';
+export declare class UserConnectedAccountModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends UserConnectedAccountSelect>(args: FindManyArgs<S, UserConnectedAccountFilter, UserConnectedAccountOrderBy> & {
+        select: S;
+    } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
+        userConnectedAccounts: ConnectionResult<InferSelectResult<UserConnectedAccountWithRelations, S>>;
+    }>;
+    findFirst<S extends UserConnectedAccountSelect>(args: FindFirstArgs<S, UserConnectedAccountFilter> & {
+        select: S;
+    } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
+        userConnectedAccounts: {
+            nodes: InferSelectResult<UserConnectedAccountWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends UserConnectedAccountSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
+        userConnectedAccount: InferSelectResult<UserConnectedAccountWithRelations, S> | null;
+    }>;
+    create<S extends UserConnectedAccountSelect>(args: CreateArgs<S, CreateUserConnectedAccountInput['userConnectedAccount']> & {
+        select: S;
+    } & StrictSelect<S, UserConnectedAccountSelect>): QueryBuilder<{
+        createUserConnectedAccount: {
+            userConnectedAccount: InferSelectResult<UserConnectedAccountWithRelations, S>;
+        };
+    }>;
+}

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

@@ -0,0 +1,72 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class UserConnectedAccountModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('UserConnectedAccount', 'userConnectedAccounts', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'UserConnectedAccountFilter', 'UserConnectedAccountOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'UserConnectedAccount',
+            fieldName: 'userConnectedAccounts',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('UserConnectedAccount', 'userConnectedAccounts', args.select, {
+            where: args?.where,
+        }, 'UserConnectedAccountFilter', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'UserConnectedAccount',
+            fieldName: 'userConnectedAccounts',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('UserConnectedAccount', 'userConnectedAccounts', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'UserConnectedAccountFilter', 'UserConnectedAccountOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'UserConnectedAccount',
+            fieldName: 'userConnectedAccount',
+            document,
+            variables,
+            transform: (data) => ({
+                userConnectedAccount: data.userConnectedAccounts?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('UserConnectedAccount', 'createUserConnectedAccount', 'userConnectedAccount', args.select, args.data, 'CreateUserConnectedAccountInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'UserConnectedAccount',
+            fieldName: 'createUserConnectedAccount',
+            document,
+            variables,
+        });
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * WebauthnCredentialsModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { WebauthnCredentialsModuleWithRelations, WebauthnCredentialsModuleSelect, WebauthnCredentialsModuleFilter, WebauthnCredentialsModuleOrderBy, CreateWebauthnCredentialsModuleInput, WebauthnCredentialsModulePatch } from '../input-types';
+export declare class WebauthnCredentialsModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends WebauthnCredentialsModuleSelect>(args: FindManyArgs<S, WebauthnCredentialsModuleFilter, WebauthnCredentialsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        webauthnCredentialsModules: ConnectionResult<InferSelectResult<WebauthnCredentialsModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends WebauthnCredentialsModuleSelect>(args: FindFirstArgs<S, WebauthnCredentialsModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        webauthnCredentialsModules: {
+            nodes: InferSelectResult<WebauthnCredentialsModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends WebauthnCredentialsModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        webauthnCredentialsModule: InferSelectResult<WebauthnCredentialsModuleWithRelations, S> | null;
+    }>;
+    create<S extends WebauthnCredentialsModuleSelect>(args: CreateArgs<S, CreateWebauthnCredentialsModuleInput['webauthnCredentialsModule']> & {
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        createWebauthnCredentialsModule: {
+            webauthnCredentialsModule: InferSelectResult<WebauthnCredentialsModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends WebauthnCredentialsModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, WebauthnCredentialsModulePatch> & {
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        updateWebauthnCredentialsModule: {
+            webauthnCredentialsModule: InferSelectResult<WebauthnCredentialsModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends WebauthnCredentialsModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, WebauthnCredentialsModuleSelect>): QueryBuilder<{
+        deleteWebauthnCredentialsModule: {
+            webauthnCredentialsModule: InferSelectResult<WebauthnCredentialsModuleWithRelations, S>;
+        };
+    }>;
+}