create-croissant 0.1.0 → 0.1.1

package/template/apps/web/node_modules/@better-auth/core/dist/db/get-tables.mjs

@@ -0,0 +1,265 @@
+//#region src/db/get-tables.ts
+const getAuthTables = (options) => {
+	const pluginSchema = (options.plugins ?? []).reduce((acc, plugin) => {
+		const schema = plugin.schema;
+		if (!schema) return acc;
+		for (const [key, value] of Object.entries(schema)) acc[key] = {
+			fields: {
+				...acc[key]?.fields,
+				...value.fields
+			},
+			modelName: value.modelName || key
+		};
+		return acc;
+	}, {});
+	const shouldAddRateLimitTable = options.rateLimit?.storage === "database";
+	const rateLimitTable = { rateLimit: {
+		modelName: options.rateLimit?.modelName || "rateLimit",
+		fields: {
+			key: {
+				type: "string",
+				unique: true,
+				required: true,
+				fieldName: options.rateLimit?.fields?.key || "key"
+			},
+			count: {
+				type: "number",
+				required: true,
+				fieldName: options.rateLimit?.fields?.count || "count"
+			},
+			lastRequest: {
+				type: "number",
+				bigint: true,
+				required: true,
+				fieldName: options.rateLimit?.fields?.lastRequest || "lastRequest",
+				defaultValue: () => Date.now()
+			}
+		}
+	} };
+	const { user, session, account, verification, ...pluginTables } = pluginSchema;
+	const verificationTable = { verification: {
+		modelName: options.verification?.modelName || "verification",
+		fields: {
+			identifier: {
+				type: "string",
+				required: true,
+				fieldName: options.verification?.fields?.identifier || "identifier",
+				index: true
+			},
+			value: {
+				type: "string",
+				required: true,
+				fieldName: options.verification?.fields?.value || "value"
+			},
+			expiresAt: {
+				type: "date",
+				required: true,
+				fieldName: options.verification?.fields?.expiresAt || "expiresAt"
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => /* @__PURE__ */ new Date(),
+				fieldName: options.verification?.fields?.createdAt || "createdAt"
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => /* @__PURE__ */ new Date(),
+				onUpdate: () => /* @__PURE__ */ new Date(),
+				fieldName: options.verification?.fields?.updatedAt || "updatedAt"
+			},
+			...verification?.fields,
+			...options.verification?.additionalFields
+		},
+		order: 4
+	} };
+	const sessionTable = { session: {
+		modelName: options.session?.modelName || "session",
+		fields: {
+			expiresAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.expiresAt || "expiresAt"
+			},
+			token: {
+				type: "string",
+				required: true,
+				fieldName: options.session?.fields?.token || "token",
+				unique: true
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.createdAt || "createdAt",
+				defaultValue: () => /* @__PURE__ */ new Date()
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.updatedAt || "updatedAt",
+				onUpdate: () => /* @__PURE__ */ new Date()
+			},
+			ipAddress: {
+				type: "string",
+				required: false,
+				fieldName: options.session?.fields?.ipAddress || "ipAddress"
+			},
+			userAgent: {
+				type: "string",
+				required: false,
+				fieldName: options.session?.fields?.userAgent || "userAgent"
+			},
+			userId: {
+				type: "string",
+				fieldName: options.session?.fields?.userId || "userId",
+				references: {
+					model: options.user?.modelName || "user",
+					field: "id",
+					onDelete: "cascade"
+				},
+				required: true,
+				index: true
+			},
+			...session?.fields,
+			...options.session?.additionalFields
+		},
+		order: 2
+	} };
+	return {
+		user: {
+			modelName: options.user?.modelName || "user",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					fieldName: options.user?.fields?.name || "name",
+					sortable: true
+				},
+				email: {
+					type: "string",
+					unique: true,
+					required: true,
+					fieldName: options.user?.fields?.email || "email",
+					sortable: true
+				},
+				emailVerified: {
+					type: "boolean",
+					defaultValue: false,
+					required: true,
+					fieldName: options.user?.fields?.emailVerified || "emailVerified",
+					input: false
+				},
+				image: {
+					type: "string",
+					required: false,
+					fieldName: options.user?.fields?.image || "image"
+				},
+				createdAt: {
+					type: "date",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.createdAt || "createdAt"
+				},
+				updatedAt: {
+					type: "date",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.updatedAt || "updatedAt"
+				},
+				...user?.fields,
+				...options.user?.additionalFields
+			},
+			order: 1
+		},
+		...!options.secondaryStorage || options.session?.storeSessionInDatabase ? sessionTable : {},
+		account: {
+			modelName: options.account?.modelName || "account",
+			fields: {
+				accountId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.accountId || "accountId"
+				},
+				providerId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.providerId || "providerId"
+				},
+				userId: {
+					type: "string",
+					references: {
+						model: options.user?.modelName || "user",
+						field: "id",
+						onDelete: "cascade"
+					},
+					required: true,
+					fieldName: options.account?.fields?.userId || "userId",
+					index: true
+				},
+				accessToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.accessToken || "accessToken"
+				},
+				refreshToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.refreshToken || "refreshToken"
+				},
+				idToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.idToken || "idToken"
+				},
+				accessTokenExpiresAt: {
+					type: "date",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.accessTokenExpiresAt || "accessTokenExpiresAt"
+				},
+				refreshTokenExpiresAt: {
+					type: "date",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.refreshTokenExpiresAt || "refreshTokenExpiresAt"
+				},
+				scope: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.scope || "scope"
+				},
+				password: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.password || "password"
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.createdAt || "createdAt",
+					defaultValue: () => /* @__PURE__ */ new Date()
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.updatedAt || "updatedAt",
+					onUpdate: () => /* @__PURE__ */ new Date()
+				},
+				...account?.fields,
+				...options.account?.additionalFields
+			},
+			order: 3
+		},
+		...!options.secondaryStorage || options.verification?.storeInDatabase ? verificationTable : {},
+		...pluginTables,
+		...shouldAddRateLimitTable ? rateLimitTable : {}
+	};
+};
+//#endregion
+export { getAuthTables };

package/template/apps/web/node_modules/@better-auth/core/dist/db/index.d.mts

@@ -0,0 +1,10 @@
+import { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, InferDBFieldInput, InferDBFieldOutput, InferDBFieldsFromOptions, InferDBFieldsFromOptionsInput, InferDBFieldsFromPlugins, InferDBFieldsFromPluginsInput, InferDBFieldsInput, InferDBFieldsOutput, InferDBValueType, ModelNames, SecondaryStorage } from "./type.mjs";
+import { getAuthTables } from "./get-tables.mjs";
+import { BetterAuthPluginDBSchema } from "./plugin.mjs";
+import { BaseRateLimit, RateLimit, rateLimitSchema } from "./schema/rate-limit.mjs";
+import { BaseSession, Session, sessionSchema } from "./schema/session.mjs";
+import { BaseUser, User, userSchema } from "./schema/user.mjs";
+import { BaseVerification, Verification, verificationSchema } from "./schema/verification.mjs";
+import { Account, BaseAccount, accountSchema } from "./schema/account.mjs";
+import { coreSchema } from "./schema/shared.mjs";
+export { type Account, type BaseAccount, type BaseModelNames, type BaseRateLimit, type BaseSession, type BaseUser, type BaseVerification, type BetterAuthDBSchema, type BetterAuthPluginDBSchema, type DBFieldAttribute, type DBFieldAttributeConfig, type DBFieldType, type DBPrimitive, type InferDBFieldInput, type InferDBFieldOutput, type InferDBFieldsFromOptions, type InferDBFieldsFromOptionsInput, type InferDBFieldsFromPlugins, type InferDBFieldsFromPluginsInput, type InferDBFieldsInput, type InferDBFieldsOutput, type InferDBValueType, type ModelNames, type RateLimit, type SecondaryStorage, type Session, type User, type Verification, accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/index.mjs

@@ -0,0 +1,8 @@
+import { getAuthTables } from "./get-tables.mjs";
+import { coreSchema } from "./schema/shared.mjs";
+import { accountSchema } from "./schema/account.mjs";
+import { rateLimitSchema } from "./schema/rate-limit.mjs";
+import { sessionSchema } from "./schema/session.mjs";
+import { userSchema } from "./schema/user.mjs";
+import { verificationSchema } from "./schema/verification.mjs";
+export { accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/plugin.d.mts

@@ -0,0 +1,12 @@
+import { DBFieldAttribute } from "./type.mjs";
+
+//#region src/db/plugin.d.ts
+type BetterAuthPluginDBSchema = { [table in string]: {
+  fields: {
+    [field: string]: DBFieldAttribute;
+  };
+  disableMigration?: boolean | undefined;
+  modelName?: string | undefined;
+} };
+//#endregion
+export { BetterAuthPluginDBSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/account.d.mts

@@ -0,0 +1,28 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/account.d.ts
+declare const accountSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  providerId: z.ZodString;
+  accountId: z.ZodString;
+  userId: z.ZodCoercedString<unknown>;
+  accessToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  refreshToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  idToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  accessTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+  refreshTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+  scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseAccount = z.infer<typeof accountSchema>;
+/**
+ * Account schema type used by better-auth, note that it's possible that account could have additional fields
+ */
+type Account<DBOptions extends BetterAuthOptions["account"] = BetterAuthOptions["account"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseAccount & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"account", Plugins>>;
+//#endregion
+export { Account, BaseAccount, accountSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/account.mjs

@@ -0,0 +1,17 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/account.ts
+const accountSchema = coreSchema.extend({
+	providerId: z.string(),
+	accountId: z.string(),
+	userId: z.coerce.string(),
+	accessToken: z.string().nullish(),
+	refreshToken: z.string().nullish(),
+	idToken: z.string().nullish(),
+	accessTokenExpiresAt: z.date().nullish(),
+	refreshTokenExpiresAt: z.date().nullish(),
+	scope: z.string().nullish(),
+	password: z.string().nullish()
+});
+//#endregion
+export { accountSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/rate-limit.d.mts

@@ -0,0 +1,18 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/rate-limit.d.ts
+declare const rateLimitSchema: z.ZodObject<{
+  key: z.ZodString;
+  count: z.ZodNumber;
+  lastRequest: z.ZodNumber;
+}, z.core.$strip>;
+type BaseRateLimit = z.infer<typeof rateLimitSchema>;
+/**
+ * Rate limit schema type used by better-auth for rate limiting
+ */
+type RateLimit<DBOptions extends BetterAuthOptions["rateLimit"] = BetterAuthOptions["rateLimit"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseRateLimit & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"rateLimit", Plugins>>;
+//#endregion
+export { BaseRateLimit, RateLimit, rateLimitSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/rate-limit.mjs

@@ -0,0 +1,9 @@
+import * as z from "zod";
+//#region src/db/schema/rate-limit.ts
+const rateLimitSchema = z.object({
+	key: z.string(),
+	count: z.number(),
+	lastRequest: z.number()
+});
+//#endregion
+export { rateLimitSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/session.d.mts

@@ -0,0 +1,23 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/session.d.ts
+declare const sessionSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  userId: z.ZodCoercedString<unknown>;
+  expiresAt: z.ZodDate;
+  token: z.ZodString;
+  ipAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseSession = z.infer<typeof sessionSchema>;
+/**
+ * Session schema type used by better-auth, note that it's possible that session could have additional fields
+ */
+type Session<DBOptions extends BetterAuthOptions["session"] = BetterAuthOptions["session"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<z.infer<typeof sessionSchema> & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"session", Plugins>>;
+//#endregion
+export { BaseSession, Session, sessionSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/session.mjs

@@ -0,0 +1,12 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/session.ts
+const sessionSchema = coreSchema.extend({
+	userId: z.coerce.string(),
+	expiresAt: z.date(),
+	token: z.string(),
+	ipAddress: z.string().nullish(),
+	userAgent: z.string().nullish()
+});
+//#endregion
+export { sessionSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/shared.d.mts

@@ -0,0 +1,10 @@
+import * as z from "zod";
+
+//#region src/db/schema/shared.d.ts
+declare const coreSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+}, z.core.$strip>;
+//#endregion
+export { coreSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/shared.mjs

@@ -0,0 +1,9 @@
+import * as z from "zod";
+//#region src/db/schema/shared.ts
+const coreSchema = z.object({
+	id: z.string(),
+	createdAt: z.date().default(() => /* @__PURE__ */ new Date()),
+	updatedAt: z.date().default(() => /* @__PURE__ */ new Date())
+});
+//#endregion
+export { coreSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/user.d.mts

@@ -0,0 +1,22 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/user.d.ts
+declare const userSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  email: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+  emailVerified: z.ZodDefault<z.ZodBoolean>;
+  name: z.ZodString;
+  image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseUser = z.infer<typeof userSchema>;
+/**
+ * User schema type used by better-auth, note that it's possible that user could have additional fields
+ */
+type User<DBOptions extends BetterAuthOptions["user"] = BetterAuthOptions["user"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseUser & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"user", Plugins>>;
+//#endregion
+export { BaseUser, User, userSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/user.mjs

@@ -0,0 +1,11 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/user.ts
+const userSchema = coreSchema.extend({
+	email: z.string().transform((val) => val.toLowerCase()),
+	emailVerified: z.boolean().default(false),
+	name: z.string(),
+	image: z.string().nullish()
+});
+//#endregion
+export { userSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/verification.d.mts

@@ -0,0 +1,21 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/verification.d.ts
+declare const verificationSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  value: z.ZodString;
+  expiresAt: z.ZodDate;
+  identifier: z.ZodString;
+}, z.core.$strip>;
+type BaseVerification = z.infer<typeof verificationSchema>;
+/**
+ * Verification schema type used by better-auth, note that it's possible that verification could have additional fields
+ */
+type Verification<DBOptions extends BetterAuthOptions["verification"] = BetterAuthOptions["verification"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseVerification & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"verification", Plugins>>;
+//#endregion
+export { BaseVerification, Verification, verificationSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/schema/verification.mjs

@@ -0,0 +1,10 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/verification.ts
+const verificationSchema = coreSchema.extend({
+	value: z.string(),
+	expiresAt: z.date(),
+	identifier: z.string()
+});
+//#endregion
+export { verificationSchema };

package/template/apps/web/node_modules/@better-auth/core/dist/db/type.d.mts

@@ -0,0 +1,167 @@
+import { Awaitable, LiteralString, UnionToIntersection } from "../types/helper.mjs";
+import { BetterAuthOptions } from "../types/init-options.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/db/type.d.ts
+type BaseModelNames = "user" | "account" | "session" | "verification";
+type ModelNames<T extends string = LiteralString> = BaseModelNames | T | "rate-limit";
+type InferDBValueType<T extends DBFieldType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : T extends "json" ? Record<string, any> : T extends `${infer U}[]` ? U extends "string" ? string[] : number[] : T extends Array<any> ? T[number] : never;
+type InferDBFieldOutput<T extends DBFieldAttribute> = T["returned"] extends false ? never : T["required"] extends false ? InferDBValueType<T["type"]> | undefined | null : InferDBValueType<T["type"]>;
+type InferDBFieldInput<T extends DBFieldAttribute> = InferDBValueType<T["type"]>;
+type InferDBFieldsInput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferDBFieldInput<Field[key]> } & { [key in Key as Field[key]["input"] extends false ? never : key]?: InferDBFieldInput<Field[key]> | undefined | null } : {};
+type InferDBFieldsOutput<Fields extends Record<string, DBFieldAttribute>> = Fields extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? key : never : key]: InferDBFieldOutput<Fields[key]> } & { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? never : key : never]?: InferDBFieldOutput<Fields[key]> | null } : never;
+type InferDBFieldsFromOptionsInput<DBOptions extends BetterAuthOptions["session"] | BetterAuthOptions["user"] | BetterAuthOptions["verification"] | BetterAuthOptions["account"] | BetterAuthOptions["rateLimit"]> = DBOptions extends {
+  additionalFields: Record<string, DBFieldAttribute>;
+} ? InferDBFieldsInput<DBOptions["additionalFields"]> : {};
+type InferDBFieldsFromOptions<DBOptions extends BetterAuthOptions["session"] | BetterAuthOptions["user"] | BetterAuthOptions["verification"] | BetterAuthOptions["account"] | BetterAuthOptions["rateLimit"]> = DBOptions extends {
+  additionalFields: Record<string, DBFieldAttribute>;
+} ? InferDBFieldsOutput<DBOptions["additionalFields"]> : {};
+type InferDBFieldsFromPluginsInput<ModelName extends string, Plugins extends unknown[] | undefined> = Plugins extends [] ? {} : Plugins extends [infer P, ...infer Rest] ? P extends {
+  schema: { [key in ModelName]: {
+    fields: infer Fields;
+  } };
+} ? Fields extends Record<string, DBFieldAttribute> ? UnionToIntersection<InferDBFieldsInput<Fields> & InferDBFieldsFromPluginsInput<ModelName, Rest>> : InferDBFieldsFromPluginsInput<ModelName, Rest> : InferDBFieldsFromPluginsInput<ModelName, Rest> : {};
+type InferDBFieldsFromPlugins<ModelName extends string, Plugins extends unknown[] | undefined> = Plugins extends [] ? {} : Plugins extends [infer P, ...infer Rest] ? P extends {
+  schema: { [key in ModelName]: {
+    fields: infer Fields;
+  } };
+} ? Fields extends Record<string, DBFieldAttribute> ? UnionToIntersection<InferDBFieldsOutput<Fields> & InferDBFieldsFromPlugins<ModelName, Rest>> : InferDBFieldsFromPlugins<ModelName, Rest> : InferDBFieldsFromPlugins<ModelName, Rest> : {};
+type DBFieldType = "string" | "number" | "boolean" | "date" | "json" | `${"string" | "number"}[]` | Array<LiteralString>;
+type DBPrimitive = string | number | boolean | Date | null | undefined | string[] | number[] | (Record<string, unknown> | unknown[]);
+type DBFieldAttributeConfig = {
+  /**
+   * If the field should be required on a new record.
+   * @default true
+   */
+  required?: boolean | undefined;
+  /**
+   * If the value should be returned on a response body.
+   * @default true
+   */
+  returned?: boolean | undefined;
+  /**
+   * If a value should be provided when creating a new record.
+   * @default true
+   */
+  input?: boolean | undefined;
+  /**
+   * Default value for the field
+   *
+   * Note: This will not create a default value on the database level. It will only
+   * be used when creating a new record.
+   */
+  defaultValue?: (DBPrimitive | (() => DBPrimitive)) | undefined;
+  /**
+   * Update value for the field
+   *
+   * Note: This will create an onUpdate trigger on the database level for supported adapters.
+   * It will be called when updating a record.
+   */
+  onUpdate?: (() => DBPrimitive) | undefined;
+  /**
+   * transform the value before storing it.
+   */
+  transform?: {
+    input?: (value: DBPrimitive) => Awaitable<DBPrimitive>;
+    output?: (value: DBPrimitive) => Awaitable<DBPrimitive>;
+  } | undefined;
+  /**
+   * Reference to another model.
+   */
+  references?: {
+    /**
+     * The model to reference.
+     */
+    model: string;
+    /**
+     * The field on the referenced model.
+     */
+    field: string;
+    /**
+     * The action to perform when the reference is deleted.
+     * @default "cascade"
+     */
+    onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+  } | undefined;
+  unique?: boolean | undefined;
+  /**
+   * If the field should be a bigint on the database instead of integer.
+   */
+  bigint?: boolean | undefined;
+  /**
+   * A zod schema to validate the value.
+   */
+  validator?: {
+    input?: StandardSchemaV1;
+    output?: StandardSchemaV1;
+  } | undefined;
+  /**
+   * The name of the field on the database.
+   */
+  fieldName?: string | undefined;
+  /**
+   * If the field should be sortable.
+   *
+   * applicable only for `text` type.
+   * It's useful to mark fields varchar instead of text.
+   */
+  sortable?: boolean | undefined;
+  /**
+   * If the field should be indexed.
+   * @default false
+   */
+  index?: boolean | undefined;
+};
+type DBFieldAttribute<T extends DBFieldType = DBFieldType> = {
+  type: T;
+} & DBFieldAttributeConfig;
+type BetterAuthDBSchema = Record<string, {
+  /**
+   * The name of the table in the database
+   */
+  modelName: string;
+  /**
+   * The fields of the table
+   */
+  fields: Record<string, DBFieldAttribute>;
+  /**
+   * Whether to disable migrations for this table
+   * @default false
+   */
+  disableMigrations?: boolean | undefined;
+  /**
+   * The order of the table
+   */
+  order?: number | undefined;
+}>;
+interface SecondaryStorage {
+  /**
+   *
+   * @param key - Key to get
+   * @returns - Value of the key
+   */
+  get: (key: string) => Awaitable<unknown>;
+  set: (
+  /**
+   * Key to store
+   */
+
+  key: string,
+  /**
+   * Value to store
+   */
+
+  value: string,
+  /**
+   * Time to live in seconds
+   */
+
+  ttl?: number | undefined) => Awaitable<void | null | unknown>;
+  /**
+   *
+   * @param key - Key to delete
+   */
+  delete: (key: string) => Awaitable<void | null | string>;
+}
+//#endregion
+export { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, InferDBFieldInput, InferDBFieldOutput, InferDBFieldsFromOptions, InferDBFieldsFromOptionsInput, InferDBFieldsFromPlugins, InferDBFieldsFromPluginsInput, InferDBFieldsInput, InferDBFieldsOutput, InferDBValueType, ModelNames, SecondaryStorage };