@better-auth/core 1.4.12-beta.2 → 1.4.13

package/dist/db/adapter/types.d.mts

@@ -0,0 +1,139 @@
+import { BetterAuthDBSchema, DBFieldAttribute } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { CustomAdapter, DBAdapterFactoryConfig, DBAdapterSchemaCreation, DBTransactionAdapter, JoinConfig, Where } from "./index.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
+
+//#region src/db/adapter/types.d.ts
+type AdapterFactoryOptions = {
+  config: AdapterFactoryConfig;
+  adapter: AdapterFactoryCustomizeAdapterCreator;
+};
+interface AdapterFactoryConfig extends Omit<DBAdapterFactoryConfig<BetterAuthOptions>, "transaction"> {
+  /**
+   * Execute multiple operations in a transaction.
+   *
+   * If the database doesn't support transactions, set this to `false` and operations will be executed sequentially.
+   *
+   * @default false
+   */
+  transaction?: (false | (<R>(callback: (trx: DBTransactionAdapter) => Promise<R>) => Promise<R>)) | undefined;
+}
+type AdapterFactoryCustomizeAdapterCreator = (config: {
+  options: BetterAuthOptions;
+  /**
+   * The schema of the user's Better-Auth instance.
+   */
+  schema: BetterAuthDBSchema;
+  /**
+   * The debug log function.
+   *
+   * If the config has defined `debugLogs` as `false`, no logs will be shown.
+   */
+  debugLog: (...args: unknown[]) => void;
+  /**
+   * Get the model name which is expected to be saved in the database based on the user's schema.
+   */
+  getModelName: (model: string) => string;
+  /**
+   * Get the field name which is expected to be saved in the database based on the user's schema.
+   */
+  getFieldName: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => string;
+  /**
+   * This function helps us get the default model name from the schema defined by devs.
+   * Often times, the user will be using the `modelName` which could had been customized by the users.
+   * This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+   *
+   * If it's still unclear what this does:
+   *
+   * 1. User can define a custom modelName.
+   * 2. When using a custom modelName, doing something like `schema[model]` will not work.
+   * 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+   * 4. Thus allowing us to use `schema[model]`.
+   */
+  getDefaultModelName: (model: string) => string;
+  /**
+   * This function helps us get the default field name from the schema defined by devs.
+   * Often times, the user will be using the `fieldName` which could had been customized by the users.
+   * This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+   *
+   * If it's still unclear what this does:
+   *
+   * 1. User can define a custom fieldName.
+   * 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+   *
+   */
+  getDefaultFieldName: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => string;
+  /**
+   * Get the field attributes for a given model and field.
+   *
+   * Note: any model name or field name is allowed, whether default to schema or not.
+   */
+  getFieldAttributes: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => DBFieldAttribute;
+  transformInput: (data: Record<string, unknown>, defaultModelName: string, action: "create" | "update", forceAllowId?: boolean | undefined) => Promise<Record<string, unknown>>;
+  transformOutput: (data: Record<string, unknown>, defaultModelName: string, select?: string[] | undefined, joinConfig?: JoinConfig | undefined) => Promise<Record<string, unknown>>;
+  transformWhereClause: <W extends Where[] | undefined>({
+    model,
+    where,
+    action
+  }: {
+    where: W;
+    model: string;
+    action: "create" | "update" | "findOne" | "findMany" | "updateMany" | "delete" | "deleteMany" | "count";
+  }) => W extends undefined ? undefined : CleanedWhere[];
+}) => CustomAdapter$1;
+/**
+ * @deprecated Use `CustomAdapter` from `@better-auth/core/db/adapter` instead.
+ */
+interface CustomAdapter$1 extends Omit<CustomAdapter, "createSchema"> {
+  createSchema?: ((props: {
+    /**
+     * The file the user may have passed in to the `generate` command as the expected schema file output path.
+     */
+    file?: string;
+    /**
+     * The tables from the user's Better-Auth instance schema.
+     */
+    tables: BetterAuthDBSchema;
+  }) => Promise<DBAdapterSchemaCreation>) | undefined;
+}
+/**
+ * @deprecated Use `CleanedWhere` from `@better-auth/core/db/adapter` instead.
+ */
+type CleanedWhere = Prettify<Required<Where>>;
+type AdapterTestDebugLogs = {
+  resetDebugLogs: () => void;
+  printDebugLogs: () => void;
+};
+/**
+ * @deprecated Use `AdapterFactoryOptions` instead. This export will be removed in a future version.
+ */
+type CreateAdapterOptions = AdapterFactoryOptions;
+/**
+ * @deprecated Use `AdapterFactoryConfig` instead. This export will be removed in a future version.
+ */
+type AdapterConfig = AdapterFactoryConfig;
+/**
+ * @deprecated Use `AdapterFactoryCustomizeAdapterCreator` instead. This export will be removed in a future version.
+ */
+type CreateCustomAdapter = AdapterFactoryCustomizeAdapterCreator;
+//#endregion
+export { AdapterConfig, AdapterFactoryConfig, AdapterFactoryCustomizeAdapterCreator, AdapterFactoryOptions, AdapterTestDebugLogs, CleanedWhere, CreateAdapterOptions, CreateCustomAdapter, CustomAdapter$1 as CustomAdapter };

package/dist/db/adapter/utils.d.mts

@@ -0,0 +1,7 @@
+import { DBFieldAttribute } from "../type.mjs";
+
+//#region src/db/adapter/utils.d.ts
+declare function withApplyDefault(value: any, field: DBFieldAttribute, action: "create" | "update" | "findOne" | "findMany"): any;
+declare function deepmerge<T>(target: T, source: Partial<T>): T;
+//#endregion
+export { deepmerge, withApplyDefault };

package/dist/db/adapter/utils.mjs

@@ -0,0 +1,38 @@
+//#region src/db/adapter/utils.ts
+function withApplyDefault(value, field, action) {
+	if (action === "update") {
+		if (value === void 0 && field.onUpdate !== void 0) {
+			if (typeof field.onUpdate === "function") return field.onUpdate();
+			return field.onUpdate;
+		}
+		return value;
+	}
+	if (action === "create") {
+		if (value === void 0 || field.required === true && value === null) {
+			if (field.defaultValue !== void 0) {
+				if (typeof field.defaultValue === "function") return field.defaultValue();
+				return field.defaultValue;
+			}
+		}
+	}
+	return value;
+}
+function isObject(item) {
+	return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+function deepmerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	else if (isObject(target) && isObject(source)) {
+		const result = { ...target };
+		for (const [key, value] of Object.entries(source)) {
+			if (value === void 0) continue;
+			if (key in target) result[key] = deepmerge(target[key], value);
+			else result[key] = value;
+		}
+		return result;
+	}
+	return source;
+}
+
+//#endregion
+export { deepmerge, withApplyDefault };

package/dist/db/get-tables.d.mts

@@ -0,0 +1,8 @@
+import { BetterAuthDBSchema } from "./type.mjs";
+import { BetterAuthOptions } from "../types/init-options.mjs";
+import "../types/index.mjs";
+
+//#region src/db/get-tables.d.ts
+declare const getAuthTables: (options: BetterAuthOptions) => BetterAuthDBSchema;
+//#endregion
+export { getAuthTables };

package/dist/{get-tables-CMc_Emww.mjs → db/get-tables.mjs}

@@ -251,4 +251,4 @@ const getAuthTables = (options) => {
 };
 
 //#endregion
-export { getAuthTables as t };
+export { getAuthTables };

package/dist/db/index.d.mts

@@ -1,2 +1,10 @@
-import { Ar as User, Br as getAuthTables, Fr as RateLimit, Gr as DBFieldType, Hr as BetterAuthDBSchema, Ir as rateLimitSchema, Jr as SecondaryStorage, Kr as DBPrimitive, Lr as Account, Mr as coreSchema, Nr as Session, Or as Verification, Pr as sessionSchema, Rr as accountSchema, Ur as DBFieldAttribute, Vr as BaseModelNames, Wr as DBFieldAttributeConfig, jr as userSchema, kr as verificationSchema, qr as ModelNames, zr as BetterAuthPluginDBSchema } from "../index-zgYuzZ7O.mjs";
-export { Account, BaseModelNames, BetterAuthDBSchema, BetterAuthPluginDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, ModelNames, RateLimit, SecondaryStorage, Session, User, Verification, accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };
+import { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, ModelNames, SecondaryStorage } from "./type.mjs";
+import { getAuthTables } from "./get-tables.mjs";
+import { BetterAuthPluginDBSchema } from "./plugin.mjs";
+import { Account, accountSchema } from "./schema/account.mjs";
+import { RateLimit, rateLimitSchema } from "./schema/rate-limit.mjs";
+import { Session, sessionSchema } from "./schema/session.mjs";
+import { coreSchema } from "./schema/shared.mjs";
+import { User, userSchema } from "./schema/user.mjs";
+import { Verification, verificationSchema } from "./schema/verification.mjs";
+export { type Account, type BaseModelNames, type BetterAuthDBSchema, type BetterAuthPluginDBSchema, type DBFieldAttribute, type DBFieldAttributeConfig, type DBFieldType, type DBPrimitive, type ModelNames, type RateLimit, type SecondaryStorage, type Session, type User, type Verification, accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/db/index.mjs

@@ -1,62 +1,9 @@
-import { t as getAuthTables } from "../get-tables-CMc_Emww.mjs";
-import * as z from "zod";
+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";
 
-//#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
-//#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
-//#region src/db/schema/rate-limit.ts
-const rateLimitSchema = z.object({
-	key: z.string(),
-	count: z.number(),
-	lastRequest: z.number()
-});
-
-//#endregion
-//#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
-//#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
-//#region src/db/schema/verification.ts
-const verificationSchema = coreSchema.extend({
-	value: z.string(),
-	expiresAt: z.date(),
-	identifier: z.string()
-});
-
-//#endregion
 export { accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/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/dist/db/schema/account.d.mts

@@ -0,0 +1,26 @@
+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>;
+/**
+ * Account schema type used by better-auth, note that it's possible that account could have additional fields
+ *
+ * todo: we should use generics to extend this type with additional fields from plugins and options in the future
+ */
+type Account = z.infer<typeof accountSchema>;
+//#endregion
+export { Account, accountSchema };

package/dist/db/schema/account.mjs

@@ -0,0 +1,19 @@
+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/dist/db/schema/rate-limit.d.mts

@@ -0,0 +1,14 @@
+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>;
+/**
+ * Rate limit schema type used by better-auth for rate limiting
+ */
+type RateLimit = z.infer<typeof rateLimitSchema>;
+//#endregion
+export { RateLimit, rateLimitSchema };

package/dist/db/schema/rate-limit.mjs

@@ -0,0 +1,11 @@
+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/dist/db/schema/session.d.mts

@@ -0,0 +1,21 @@
+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>;
+/**
+ * Session schema type used by better-auth, note that it's possible that session could have additional fields
+ *
+ * todo: we should use generics to extend this type with additional fields from plugins and options in the future
+ */
+type Session = z.infer<typeof sessionSchema>;
+//#endregion
+export { Session, sessionSchema };

package/dist/db/schema/session.mjs

@@ -0,0 +1,14 @@
+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/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/dist/db/schema/shared.mjs

@@ -0,0 +1,11 @@
+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/dist/db/schema/user.d.mts

@@ -0,0 +1,20 @@
+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>;
+/**
+ * User schema type used by better-auth, note that it's possible that user could have additional fields
+ *
+ * todo: we should use generics to extend this type with additional fields from plugins and options in the future
+ */
+type User = z.infer<typeof userSchema>;
+//#endregion
+export { User, userSchema };

package/dist/db/schema/user.mjs

@@ -0,0 +1,13 @@
+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/dist/db/schema/verification.d.mts

@@ -0,0 +1,19 @@
+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>;
+/**
+ * Verification schema type used by better-auth, note that it's possible that verification could have additional fields
+ *
+ * todo: we should use generics to extend this type with additional fields from plugins and options in the future
+ */
+type Verification = z.infer<typeof verificationSchema>;
+//#endregion
+export { Verification, verificationSchema };

package/dist/db/schema/verification.mjs

@@ -0,0 +1,12 @@
+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/dist/db/type.d.mts

@@ -0,0 +1,143 @@
+import { Awaitable, LiteralString } from "../types/helper.mjs";
+import "../types/index.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 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, ModelNames, SecondaryStorage };

package/dist/env/color-depth.d.mts

@@ -0,0 +1,4 @@
+//#region src/env/color-depth.d.ts
+declare function getColorDepth(): number;
+//#endregion
+export { getColorDepth };