create-einja-app 0.1.1

package/templates/turborepo-pandacss/packages/front-core/src/index.ts

@@ -0,0 +1,4 @@
+// Front Core - 公開API
+// 内部構造を隠蔽し、公開APIのみエクスポート
+
+export { baseAuthOptions, mergeAuthOptions } from "./auth";

package/templates/turborepo-pandacss/packages/front-core/src/utils/index.ts

@@ -0,0 +1,2 @@
+// Utils module - 将来拡張用
+// 共通ユーティリティをここに追加

package/templates/turborepo-pandacss/packages/front-core/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@repo/config/typescript",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/templates/turborepo-pandacss/packages/server-core/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@repo/server-core",
+  "version": "0.1.0",
+  "private": true,
+  "exports": {
+    "./*": "./src/*.ts",
+    "./testing": "./src/testing/index.ts"
+  },
+  "scripts": {
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:studio": "prisma studio",
+    "db:seed": "tsx prisma/seed.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.10.1",
+    "bcryptjs": "^3.0.2"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^9.6.0",
+    "@quramy/prisma-fabbrica": "^2.2.0",
+    "@repo/config": "workspace:*",
+    "prisma": "^6.10.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5",
+    "vitest": "^3.2.2"
+  }
+}

package/templates/turborepo-pandacss/packages/server-core/prisma/schema.prisma

@@ -0,0 +1,102 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+generator fabbrica {
+  provider = "prisma-fabbrica"
+  output   = "../src/__generated__/fabbrica"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+enum UserStatus {
+  active
+  inactive
+  pending
+}
+
+enum UserRole {
+  admin
+  user
+  moderator
+}
+
+model User {
+  id            String          @id @default(cuid())
+  name          String?
+  email         String          @unique
+  emailVerified DateTime?
+  image         String?
+  password      String?         // パスワードフィールドを追加
+  status        UserStatus      @default(pending)
+  role          UserRole        @default(user)
+  lastLogin     DateTime?
+  accounts      Account[]
+  sessions      Session[]
+  // Optional for WebAuthn support
+  Authenticator Authenticator[]
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Account {
+  userId            String
+  type              String
+  provider          String
+  providerAccountId String
+  refresh_token     String?
+  access_token      String?
+  expires_at        Int?
+  token_type        String?
+  scope             String?
+  id_token          String?
+  session_state     String?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@id([provider, providerAccountId])
+}
+
+model Session {
+  sessionToken String   @unique
+  userId       String
+  expires      DateTime
+  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model VerificationToken {
+  identifier String
+  token      String
+  expires    DateTime
+
+  @@id([identifier, token])
+}
+
+// Optional for WebAuthn support
+model Authenticator {
+  credentialID         String  @unique
+  userId               String
+  providerAccountId    String
+  credentialPublicKey  String
+  counter              Int
+  credentialDeviceType String
+  credentialBackedUp   Boolean
+  transports           String?
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@id([userId, credentialID])
+}

package/templates/turborepo-pandacss/packages/server-core/prisma/seed.ts

@@ -0,0 +1,67 @@
+import { PrismaClient } from "@prisma/client";
+import {
+  SEED_USERS,
+  getDefaultHashedPassword,
+  initialize,
+  randomDate,
+  daysAgo,
+} from "../src/testing";
+
+const prisma = new PrismaClient();
+
+// fabbrica初期化
+initialize({ prisma });
+
+async function main() {
+  console.log("シードデータの投入を開始します...");
+
+  // 共通パスワード（開発環境用）
+  const hashedPassword = await getDefaultHashedPassword();
+
+  // 日付範囲
+  const now = new Date();
+  const oneMonthAgo = daysAgo(30);
+  const oneWeekAgo = daysAgo(7);
+
+  for (const userData of SEED_USERS) {
+    const createdAt = randomDate(oneMonthAgo, oneWeekAgo);
+    const lastLogin =
+      userData.status === "active"
+        ? randomDate(oneWeekAgo, now)
+        : userData.status === "inactive"
+          ? randomDate(oneMonthAgo, oneWeekAgo)
+          : null;
+
+    await prisma.user.upsert({
+      where: { email: userData.email },
+      update: {
+        name: userData.name,
+        status: userData.status,
+        role: userData.role,
+        lastLogin,
+      },
+      create: {
+        email: userData.email,
+        name: userData.name,
+        password: hashedPassword,
+        status: userData.status,
+        role: userData.role,
+        createdAt,
+        lastLogin,
+      },
+    });
+
+    console.log(`ユーザー作成: ${userData.name} (${userData.email})`);
+  }
+
+  console.log("シードデータの投入が完了しました");
+}
+
+main()
+  .catch((e) => {
+    console.error("シードエラー:", e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

package/templates/turborepo-pandacss/packages/server-core/prisma.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    seed: "npx dotenvx run -f ../../.env.example -- tsx prisma/seed.ts",
+  },
+});

package/templates/turborepo-pandacss/packages/server-core/src/__generated__/fabbrica/index.d.ts

@@ -0,0 +1,270 @@
+import type { User } from "@prisma/client";
+import type { Account } from "@prisma/client";
+import type { Session } from "@prisma/client";
+import type { VerificationToken } from "@prisma/client";
+import type { Authenticator } from "@prisma/client";
+import type { UserStatus } from "@prisma/client";
+import type { UserRole } from "@prisma/client";
+import type { Prisma } from "@prisma/client";
+import type { Resolver } from "@quramy/prisma-fabbrica/lib/internal";
+export { resetSequence, registerScalarFieldValueGenerator, resetScalarFieldValueGenerator } from "@quramy/prisma-fabbrica/lib/internal";
+type BuildDataOptions<TTransients extends Record<string, unknown>> = {
+    readonly seq: number;
+} & TTransients;
+type TraitName = string | symbol;
+type CallbackDefineOptions<TCreated, TCreateInput, TTransients extends Record<string, unknown>> = {
+    onAfterBuild?: (createInput: TCreateInput, transientFields: TTransients) => void | PromiseLike<void>;
+    onBeforeCreate?: (createInput: TCreateInput, transientFields: TTransients) => void | PromiseLike<void>;
+    onAfterCreate?: (created: TCreated, transientFields: TTransients) => void | PromiseLike<void>;
+};
+export declare const initialize: (options: import("@quramy/prisma-fabbrica/lib/internal").InitializeOptions) => void;
+type UserFactoryDefineInput = {
+    id?: string;
+    name?: string | null;
+    email?: string;
+    emailVerified?: Date | null;
+    image?: string | null;
+    password?: string | null;
+    status?: UserStatus;
+    role?: UserRole;
+    lastLogin?: Date | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+    accounts?: Prisma.AccountCreateNestedManyWithoutUserInput;
+    sessions?: Prisma.SessionCreateNestedManyWithoutUserInput;
+    Authenticator?: Prisma.AuthenticatorCreateNestedManyWithoutUserInput;
+};
+type UserTransientFields = Record<string, unknown> & Partial<Record<keyof UserFactoryDefineInput, never>>;
+type UserFactoryTrait<TTransients extends Record<string, unknown>> = {
+    data?: Resolver<Partial<UserFactoryDefineInput>, BuildDataOptions<TTransients>>;
+} & CallbackDefineOptions<User, Prisma.UserCreateInput, TTransients>;
+type UserFactoryDefineOptions<TTransients extends Record<string, unknown> = Record<string, unknown>> = {
+    defaultData?: Resolver<UserFactoryDefineInput, BuildDataOptions<TTransients>>;
+    traits?: {
+        [traitName: TraitName]: UserFactoryTrait<TTransients>;
+    };
+} & CallbackDefineOptions<User, Prisma.UserCreateInput, TTransients>;
+type UserTraitKeys<TOptions extends UserFactoryDefineOptions<any>> = Exclude<keyof TOptions["traits"], number>;
+export interface UserFactoryInterfaceWithoutTraits<TTransients extends Record<string, unknown>> {
+    readonly _factoryFor: "User";
+    build(inputData?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<Prisma.UserCreateInput>;
+    buildCreateInput(inputData?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<Prisma.UserCreateInput>;
+    buildList(list: readonly Partial<Prisma.UserCreateInput & TTransients>[]): PromiseLike<Prisma.UserCreateInput[]>;
+    buildList(count: number, item?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<Prisma.UserCreateInput[]>;
+    pickForConnect(inputData: User): Pick<User, "id">;
+    create(inputData?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<User>;
+    createList(list: readonly Partial<Prisma.UserCreateInput & TTransients>[]): PromiseLike<User[]>;
+    createList(count: number, item?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<User[]>;
+    createForConnect(inputData?: Partial<Prisma.UserCreateInput & TTransients>): PromiseLike<Pick<User, "id">>;
+}
+export interface UserFactoryInterface<TTransients extends Record<string, unknown> = Record<string, unknown>, TTraitName extends TraitName = TraitName> extends UserFactoryInterfaceWithoutTraits<TTransients> {
+    use(name: TTraitName, ...names: readonly TTraitName[]): UserFactoryInterfaceWithoutTraits<TTransients>;
+}
+interface UserFactoryBuilder {
+    <TOptions extends UserFactoryDefineOptions>(options?: TOptions): UserFactoryInterface<{}, UserTraitKeys<TOptions>>;
+    withTransientFields: <TTransients extends UserTransientFields>(defaultTransientFieldValues: TTransients) => <TOptions extends UserFactoryDefineOptions<TTransients>>(options?: TOptions) => UserFactoryInterface<TTransients, UserTraitKeys<TOptions>>;
+}
+/**
+ * Define factory for {@link User} model.
+ *
+ * @param options
+ * @returns factory {@link UserFactoryInterface}
+ */
+export declare const defineUserFactory: UserFactoryBuilder;
+type AccountuserFactory = {
+    _factoryFor: "User";
+    build: () => PromiseLike<Prisma.UserCreateNestedOneWithoutAccountsInput["create"]>;
+};
+type AccountFactoryDefineInput = {
+    type?: string;
+    provider?: string;
+    providerAccountId?: string;
+    refresh_token?: string | null;
+    access_token?: string | null;
+    expires_at?: number | null;
+    token_type?: string | null;
+    scope?: string | null;
+    id_token?: string | null;
+    session_state?: string | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+    user: AccountuserFactory | Prisma.UserCreateNestedOneWithoutAccountsInput;
+};
+type AccountTransientFields = Record<string, unknown> & Partial<Record<keyof AccountFactoryDefineInput, never>>;
+type AccountFactoryTrait<TTransients extends Record<string, unknown>> = {
+    data?: Resolver<Partial<AccountFactoryDefineInput>, BuildDataOptions<TTransients>>;
+} & CallbackDefineOptions<Account, Prisma.AccountCreateInput, TTransients>;
+type AccountFactoryDefineOptions<TTransients extends Record<string, unknown> = Record<string, unknown>> = {
+    defaultData: Resolver<AccountFactoryDefineInput, BuildDataOptions<TTransients>>;
+    traits?: {
+        [traitName: string | symbol]: AccountFactoryTrait<TTransients>;
+    };
+} & CallbackDefineOptions<Account, Prisma.AccountCreateInput, TTransients>;
+type AccountTraitKeys<TOptions extends AccountFactoryDefineOptions<any>> = Exclude<keyof TOptions["traits"], number>;
+export interface AccountFactoryInterfaceWithoutTraits<TTransients extends Record<string, unknown>> {
+    readonly _factoryFor: "Account";
+    build(inputData?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Prisma.AccountCreateInput>;
+    buildCreateInput(inputData?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Prisma.AccountCreateInput>;
+    buildList(list: readonly Partial<Prisma.AccountCreateInput & TTransients>[]): PromiseLike<Prisma.AccountCreateInput[]>;
+    buildList(count: number, item?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Prisma.AccountCreateInput[]>;
+    pickForConnect(inputData: Account): Pick<Account, "provider" | "providerAccountId">;
+    create(inputData?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Account>;
+    createList(list: readonly Partial<Prisma.AccountCreateInput & TTransients>[]): PromiseLike<Account[]>;
+    createList(count: number, item?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Account[]>;
+    createForConnect(inputData?: Partial<Prisma.AccountCreateInput & TTransients>): PromiseLike<Pick<Account, "provider" | "providerAccountId">>;
+}
+export interface AccountFactoryInterface<TTransients extends Record<string, unknown> = Record<string, unknown>, TTraitName extends TraitName = TraitName> extends AccountFactoryInterfaceWithoutTraits<TTransients> {
+    use(name: TTraitName, ...names: readonly TTraitName[]): AccountFactoryInterfaceWithoutTraits<TTransients>;
+}
+interface AccountFactoryBuilder {
+    <TOptions extends AccountFactoryDefineOptions>(options: TOptions): AccountFactoryInterface<{}, AccountTraitKeys<TOptions>>;
+    withTransientFields: <TTransients extends AccountTransientFields>(defaultTransientFieldValues: TTransients) => <TOptions extends AccountFactoryDefineOptions<TTransients>>(options: TOptions) => AccountFactoryInterface<TTransients, AccountTraitKeys<TOptions>>;
+}
+/**
+ * Define factory for {@link Account} model.
+ *
+ * @param options
+ * @returns factory {@link AccountFactoryInterface}
+ */
+export declare const defineAccountFactory: AccountFactoryBuilder;
+type SessionuserFactory = {
+    _factoryFor: "User";
+    build: () => PromiseLike<Prisma.UserCreateNestedOneWithoutSessionsInput["create"]>;
+};
+type SessionFactoryDefineInput = {
+    sessionToken?: string;
+    expires?: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+    user: SessionuserFactory | Prisma.UserCreateNestedOneWithoutSessionsInput;
+};
+type SessionTransientFields = Record<string, unknown> & Partial<Record<keyof SessionFactoryDefineInput, never>>;
+type SessionFactoryTrait<TTransients extends Record<string, unknown>> = {
+    data?: Resolver<Partial<SessionFactoryDefineInput>, BuildDataOptions<TTransients>>;
+} & CallbackDefineOptions<Session, Prisma.SessionCreateInput, TTransients>;
+type SessionFactoryDefineOptions<TTransients extends Record<string, unknown> = Record<string, unknown>> = {
+    defaultData: Resolver<SessionFactoryDefineInput, BuildDataOptions<TTransients>>;
+    traits?: {
+        [traitName: string | symbol]: SessionFactoryTrait<TTransients>;
+    };
+} & CallbackDefineOptions<Session, Prisma.SessionCreateInput, TTransients>;
+type SessionTraitKeys<TOptions extends SessionFactoryDefineOptions<any>> = Exclude<keyof TOptions["traits"], number>;
+export interface SessionFactoryInterfaceWithoutTraits<TTransients extends Record<string, unknown>> {
+    readonly _factoryFor: "Session";
+    build(inputData?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Prisma.SessionCreateInput>;
+    buildCreateInput(inputData?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Prisma.SessionCreateInput>;
+    buildList(list: readonly Partial<Prisma.SessionCreateInput & TTransients>[]): PromiseLike<Prisma.SessionCreateInput[]>;
+    buildList(count: number, item?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Prisma.SessionCreateInput[]>;
+    pickForConnect(inputData: Session): Pick<Session, "sessionToken">;
+    create(inputData?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Session>;
+    createList(list: readonly Partial<Prisma.SessionCreateInput & TTransients>[]): PromiseLike<Session[]>;
+    createList(count: number, item?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Session[]>;
+    createForConnect(inputData?: Partial<Prisma.SessionCreateInput & TTransients>): PromiseLike<Pick<Session, "sessionToken">>;
+}
+export interface SessionFactoryInterface<TTransients extends Record<string, unknown> = Record<string, unknown>, TTraitName extends TraitName = TraitName> extends SessionFactoryInterfaceWithoutTraits<TTransients> {
+    use(name: TTraitName, ...names: readonly TTraitName[]): SessionFactoryInterfaceWithoutTraits<TTransients>;
+}
+interface SessionFactoryBuilder {
+    <TOptions extends SessionFactoryDefineOptions>(options: TOptions): SessionFactoryInterface<{}, SessionTraitKeys<TOptions>>;
+    withTransientFields: <TTransients extends SessionTransientFields>(defaultTransientFieldValues: TTransients) => <TOptions extends SessionFactoryDefineOptions<TTransients>>(options: TOptions) => SessionFactoryInterface<TTransients, SessionTraitKeys<TOptions>>;
+}
+/**
+ * Define factory for {@link Session} model.
+ *
+ * @param options
+ * @returns factory {@link SessionFactoryInterface}
+ */
+export declare const defineSessionFactory: SessionFactoryBuilder;
+type VerificationTokenFactoryDefineInput = {
+    identifier?: string;
+    token?: string;
+    expires?: Date;
+};
+type VerificationTokenTransientFields = Record<string, unknown> & Partial<Record<keyof VerificationTokenFactoryDefineInput, never>>;
+type VerificationTokenFactoryTrait<TTransients extends Record<string, unknown>> = {
+    data?: Resolver<Partial<VerificationTokenFactoryDefineInput>, BuildDataOptions<TTransients>>;
+} & CallbackDefineOptions<VerificationToken, Prisma.VerificationTokenCreateInput, TTransients>;
+type VerificationTokenFactoryDefineOptions<TTransients extends Record<string, unknown> = Record<string, unknown>> = {
+    defaultData?: Resolver<VerificationTokenFactoryDefineInput, BuildDataOptions<TTransients>>;
+    traits?: {
+        [traitName: TraitName]: VerificationTokenFactoryTrait<TTransients>;
+    };
+} & CallbackDefineOptions<VerificationToken, Prisma.VerificationTokenCreateInput, TTransients>;
+type VerificationTokenTraitKeys<TOptions extends VerificationTokenFactoryDefineOptions<any>> = Exclude<keyof TOptions["traits"], number>;
+export interface VerificationTokenFactoryInterfaceWithoutTraits<TTransients extends Record<string, unknown>> {
+    readonly _factoryFor: "VerificationToken";
+    build(inputData?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<Prisma.VerificationTokenCreateInput>;
+    buildCreateInput(inputData?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<Prisma.VerificationTokenCreateInput>;
+    buildList(list: readonly Partial<Prisma.VerificationTokenCreateInput & TTransients>[]): PromiseLike<Prisma.VerificationTokenCreateInput[]>;
+    buildList(count: number, item?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<Prisma.VerificationTokenCreateInput[]>;
+    pickForConnect(inputData: VerificationToken): Pick<VerificationToken, "identifier" | "token">;
+    create(inputData?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<VerificationToken>;
+    createList(list: readonly Partial<Prisma.VerificationTokenCreateInput & TTransients>[]): PromiseLike<VerificationToken[]>;
+    createList(count: number, item?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<VerificationToken[]>;
+    createForConnect(inputData?: Partial<Prisma.VerificationTokenCreateInput & TTransients>): PromiseLike<Pick<VerificationToken, "identifier" | "token">>;
+}
+export interface VerificationTokenFactoryInterface<TTransients extends Record<string, unknown> = Record<string, unknown>, TTraitName extends TraitName = TraitName> extends VerificationTokenFactoryInterfaceWithoutTraits<TTransients> {
+    use(name: TTraitName, ...names: readonly TTraitName[]): VerificationTokenFactoryInterfaceWithoutTraits<TTransients>;
+}
+interface VerificationTokenFactoryBuilder {
+    <TOptions extends VerificationTokenFactoryDefineOptions>(options?: TOptions): VerificationTokenFactoryInterface<{}, VerificationTokenTraitKeys<TOptions>>;
+    withTransientFields: <TTransients extends VerificationTokenTransientFields>(defaultTransientFieldValues: TTransients) => <TOptions extends VerificationTokenFactoryDefineOptions<TTransients>>(options?: TOptions) => VerificationTokenFactoryInterface<TTransients, VerificationTokenTraitKeys<TOptions>>;
+}
+/**
+ * Define factory for {@link VerificationToken} model.
+ *
+ * @param options
+ * @returns factory {@link VerificationTokenFactoryInterface}
+ */
+export declare const defineVerificationTokenFactory: VerificationTokenFactoryBuilder;
+type AuthenticatoruserFactory = {
+    _factoryFor: "User";
+    build: () => PromiseLike<Prisma.UserCreateNestedOneWithoutAuthenticatorInput["create"]>;
+};
+type AuthenticatorFactoryDefineInput = {
+    credentialID?: string;
+    providerAccountId?: string;
+    credentialPublicKey?: string;
+    counter?: number;
+    credentialDeviceType?: string;
+    credentialBackedUp?: boolean;
+    transports?: string | null;
+    user: AuthenticatoruserFactory | Prisma.UserCreateNestedOneWithoutAuthenticatorInput;
+};
+type AuthenticatorTransientFields = Record<string, unknown> & Partial<Record<keyof AuthenticatorFactoryDefineInput, never>>;
+type AuthenticatorFactoryTrait<TTransients extends Record<string, unknown>> = {
+    data?: Resolver<Partial<AuthenticatorFactoryDefineInput>, BuildDataOptions<TTransients>>;
+} & CallbackDefineOptions<Authenticator, Prisma.AuthenticatorCreateInput, TTransients>;
+type AuthenticatorFactoryDefineOptions<TTransients extends Record<string, unknown> = Record<string, unknown>> = {
+    defaultData: Resolver<AuthenticatorFactoryDefineInput, BuildDataOptions<TTransients>>;
+    traits?: {
+        [traitName: string | symbol]: AuthenticatorFactoryTrait<TTransients>;
+    };
+} & CallbackDefineOptions<Authenticator, Prisma.AuthenticatorCreateInput, TTransients>;
+type AuthenticatorTraitKeys<TOptions extends AuthenticatorFactoryDefineOptions<any>> = Exclude<keyof TOptions["traits"], number>;
+export interface AuthenticatorFactoryInterfaceWithoutTraits<TTransients extends Record<string, unknown>> {
+    readonly _factoryFor: "Authenticator";
+    build(inputData?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Prisma.AuthenticatorCreateInput>;
+    buildCreateInput(inputData?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Prisma.AuthenticatorCreateInput>;
+    buildList(list: readonly Partial<Prisma.AuthenticatorCreateInput & TTransients>[]): PromiseLike<Prisma.AuthenticatorCreateInput[]>;
+    buildList(count: number, item?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Prisma.AuthenticatorCreateInput[]>;
+    pickForConnect(inputData: Authenticator): Pick<Authenticator, "userId" | "credentialID">;
+    create(inputData?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Authenticator>;
+    createList(list: readonly Partial<Prisma.AuthenticatorCreateInput & TTransients>[]): PromiseLike<Authenticator[]>;
+    createList(count: number, item?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Authenticator[]>;
+    createForConnect(inputData?: Partial<Prisma.AuthenticatorCreateInput & TTransients>): PromiseLike<Pick<Authenticator, "userId" | "credentialID">>;
+}
+export interface AuthenticatorFactoryInterface<TTransients extends Record<string, unknown> = Record<string, unknown>, TTraitName extends TraitName = TraitName> extends AuthenticatorFactoryInterfaceWithoutTraits<TTransients> {
+    use(name: TTraitName, ...names: readonly TTraitName[]): AuthenticatorFactoryInterfaceWithoutTraits<TTransients>;
+}
+interface AuthenticatorFactoryBuilder {
+    <TOptions extends AuthenticatorFactoryDefineOptions>(options: TOptions): AuthenticatorFactoryInterface<{}, AuthenticatorTraitKeys<TOptions>>;
+    withTransientFields: <TTransients extends AuthenticatorTransientFields>(defaultTransientFieldValues: TTransients) => <TOptions extends AuthenticatorFactoryDefineOptions<TTransients>>(options: TOptions) => AuthenticatorFactoryInterface<TTransients, AuthenticatorTraitKeys<TOptions>>;
+}
+/**
+ * Define factory for {@link Authenticator} model.
+ *
+ * @param options
+ * @returns factory {@link AuthenticatorFactoryInterface}
+ */
+export declare const defineAuthenticatorFactory: AuthenticatorFactoryBuilder;