payload-auth 1.4.0 → 1.5.0

package/dist/better-auth/plugin/utils/set.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Deep-sets a value on an object using a dotted-path string.
+ *
+ * **Path syntax**
+ * ──────────────────────────────────────────────────────────
+ *   token        action
+ *   ------------ ------------------------------------------
+ *   `foo.bar`    create/read plain nested objects
+ *   `foo.bar[]`  *append* `value` to array `foo.bar`
+ *   `foo.[]bar`  *prepend* `value` to array `foo.bar`
+ *   `foo.bar[2]` replace item `2` of `foo.bar`, creating
+ *                empty slots if the index is out of bounds
+ *
+ * Missing objects/arrays are created on the fly.
+ * The function mutates `target` in place and returns it so
+ * you can chain calls.
+ *
+ * @typeParam T – target object type
+ * @typeParam V – value type
+ * @param target   Object to mutate
+ * @param rawPath  Dotted path string (see syntax table)
+ * @param value    Value to set / append / prepend
+ * @returns        The original `target` reference
+ *
+ * @example
+ * const o: Record<string, unknown> = {};
+ * set(o, 'alpha.beta[2].gamma', 42);
+ * // o →
+ * // {
+ * //   alpha: {
+ * //     beta: [
+ * //       ,               // <-- empty slot #0
+ * //       ,               // <-- empty slot #1
+ * //       { gamma: 42 }   // <-- slot #2
+ * //     ]
+ * //   }
+ * // }
+ */
+export declare function set<T extends Record<string, unknown>, V = unknown>(target: T, rawPath: string, value: V): T;
+//# sourceMappingURL=set.d.ts.map

package/dist/better-auth/plugin/utils/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/utils/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAqD3G"}

package/dist/better-auth/plugin/utils/set.js

@@ -0,0 +1,84 @@
+/**
+ * Deep-sets a value on an object using a dotted-path string.
+ *
+ * **Path syntax**
+ * ──────────────────────────────────────────────────────────
+ *   token        action
+ *   ------------ ------------------------------------------
+ *   `foo.bar`    create/read plain nested objects
+ *   `foo.bar[]`  *append* `value` to array `foo.bar`
+ *   `foo.[]bar`  *prepend* `value` to array `foo.bar`
+ *   `foo.bar[2]` replace item `2` of `foo.bar`, creating
+ *                empty slots if the index is out of bounds
+ *
+ * Missing objects/arrays are created on the fly.
+ * The function mutates `target` in place and returns it so
+ * you can chain calls.
+ *
+ * @typeParam T – target object type
+ * @typeParam V – value type
+ * @param target   Object to mutate
+ * @param rawPath  Dotted path string (see syntax table)
+ * @param value    Value to set / append / prepend
+ * @returns        The original `target` reference
+ *
+ * @example
+ * const o: Record<string, unknown> = {};
+ * set(o, 'alpha.beta[2].gamma', 42);
+ * // o →
+ * // {
+ * //   alpha: {
+ * //     beta: [
+ * //       ,               // <-- empty slot #0
+ * //       ,               // <-- empty slot #1
+ * //       { gamma: 42 }   // <-- slot #2
+ * //     ]
+ * //   }
+ * // }
+ */ export function set(target, rawPath, value) {
+    if (!rawPath) return target;
+    const tokens = rawPath.split('.');
+    let node = target;
+    for(let i = 0; i < tokens.length; i += 1){
+        const raw = tokens[i];
+        const prepend = raw.startsWith('[]');
+        const append = raw.endsWith('[]');
+        const idxMatch = raw.match(/\[(\d+)]$/);
+        const hasIndex = Boolean(idxMatch);
+        const index = hasIndex ? Number(idxMatch[1]) : -1;
+        const key = prepend ? raw.slice(2) : append ? raw.slice(0, -2) : hasIndex ? raw.slice(0, raw.length - idxMatch[0].length) : raw;
+        const last = i === tokens.length - 1;
+        /* ----- prepend / append ------------------------------------------------ */ if (prepend || append) {
+            if (!Array.isArray(node[key])) node[key] = [];
+            if (last) {
+                prepend ? node[key].unshift(value) : node[key].push(value);
+                return target;
+            }
+            const next = {};
+            prepend ? node[key].unshift(next) : node[key].push(next);
+            node = next;
+            continue;
+        }
+        /* ----- explicit numeric index ----------------------------------------- */ if (hasIndex) {
+            if (!Array.isArray(node[key])) node[key] = [];
+            const arr = node[key];
+            while(arr.length <= index)arr.push(undefined);
+            if (last) {
+                arr[index] = value;
+                return target;
+            }
+            if (arr[index] === undefined) arr[index] = {};
+            node = arr[index];
+            continue;
+        }
+        /* ----- plain object step ---------------------------------------------- */ if (last) {
+            node[key] = value;
+            return target;
+        }
+        if (node[key] === undefined) node[key] = {};
+        node = node[key];
+    }
+    return target;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/scripts/generate-types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-types.d.ts.map

package/dist/better-auth/scripts/generate-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types.d.ts","sourceRoot":"","sources":["../../../src/better-auth/scripts/generate-types.ts"],"names":[],"mappings":""}

package/dist/better-auth/scripts/generate-types.js

@@ -0,0 +1,219 @@
+import { stripe } from "@better-auth/stripe";
+import { emailHarmony, phoneHarmony } from "better-auth-harmony";
+import { getSchema } from "better-auth/db";
+import { admin, anonymous, apiKey, bearer, emailOTP, genericOAuth, jwt, magicLink, multiSession, oneTap, oneTimeToken, openAPI, organization, oidcProvider, phoneNumber, twoFactor, username } from "better-auth/plugins";
+import { passkey } from "better-auth/plugins/passkey";
+import { sso } from "better-auth/plugins/sso";
+import { polar } from "@polar-sh/better-auth";
+import { Polar } from "@polar-sh/sdk";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const client = new Polar({
+    accessToken: 'pk_test_1234567890',
+    server: 'sandbox'
+});
+const plugins = [
+    username(),
+    admin(),
+    apiKey(),
+    passkey(),
+    emailHarmony(),
+    phoneHarmony(),
+    bearer(),
+    emailOTP({
+        sendVerificationOTP: async ()=>{}
+    }),
+    magicLink({
+        sendMagicLink: async ()=>{}
+    }),
+    phoneNumber({
+        sendOTP: async ()=>{}
+    }),
+    oneTap(),
+    anonymous(),
+    multiSession(),
+    oneTimeToken(),
+    oidcProvider({
+        loginPage: ''
+    }),
+    sso(),
+    genericOAuth({
+        config: [
+            {
+                providerId: 'typescript',
+                clientId: 'typescript',
+                clientSecret: 'typescript'
+            }
+        ]
+    }),
+    openAPI(),
+    organization({
+        teams: {
+            enabled: true
+        }
+    }),
+    jwt(),
+    twoFactor(),
+    phoneNumber(),
+    stripe({
+        stripeClient: {
+            apiKey: 'typescript'
+        },
+        stripeWebhookSecret: 'typescript',
+        subscription: {
+            enabled: true,
+            plans: [
+                {
+                    id: 'basic',
+                    name: 'Basic',
+                    price: 1000,
+                    interval: 'month',
+                    currency: 'usd'
+                },
+                {
+                    id: 'pro',
+                    name: 'Pro',
+                    price: 2000,
+                    interval: 'month',
+                    currency: 'usd'
+                },
+                {
+                    id: 'enterprise',
+                    name: 'Enterprise',
+                    price: 3000,
+                    interval: 'month',
+                    currency: 'usd'
+                }
+            ]
+        }
+    }),
+    // As of writing this, Polar don't create schema fields, but just in case in the future we leave this here.
+    polar({
+        client,
+        checkout: {
+            enabled: true,
+            products: [
+                {
+                    productId: 'basic',
+                    slug: 'basic'
+                },
+                {
+                    productId: 'pro',
+                    slug: 'pro'
+                },
+                {
+                    productId: 'enterprise',
+                    slug: 'enterprise'
+                }
+            ]
+        }
+    })
+];
+const betterAuthConfig = {
+    emailAndPassword: {
+        enabled: true
+    },
+    user: {
+        additionalFields: {
+            role: {
+                type: 'string',
+                defaultValue: 'user',
+                input: false
+            }
+        }
+    },
+    plugins
+};
+const baseSchema = getSchema({
+    ...betterAuthConfig,
+    plugins: []
+});
+const map = (t)=>{
+    if (t === 'boolean') return 'boolean';
+    if (t === 'date') return 'Date';
+    if (t === 'number') return 'number';
+    if (t === 'string') return 'string';
+    if (t === 'number[]') return 'number[]';
+    if (t === 'string[]') return 'string[]';
+    return 'unknown';
+};
+const pascal = (s)=>s.split(/[-_]/g).map((p)=>p.charAt(0).toUpperCase() + p.slice(1)).join('');
+const diff = (base, target)=>{
+    const d = {};
+    for (const [m, { fields }] of Object.entries(target)){
+        const added = Object.entries(fields).filter(([k])=>!(k in (base[m]?.fields ?? {})));
+        if (added.length) d[m] = Object.fromEntries(added);
+    }
+    return d;
+};
+const gen = ()=>{
+    let out = '// Auto-generated types. Do not edit.\n\n';
+    const pluginAdds = {};
+    const seen = new Set();
+    for (const pl of plugins){
+        const id = pl.id;
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        const adds = diff(baseSchema, getSchema({
+            ...betterAuthConfig,
+            plugins: [
+                pl
+            ]
+        }));
+        for (const [m, f] of Object.entries(adds)){
+            pluginAdds[m] ??= {};
+            pluginAdds[m][id] = f;
+        }
+    }
+    const models = new Set([
+        ...Object.keys(baseSchema),
+        ...Object.keys(pluginAdds)
+    ]);
+    for (const model of models){
+        const P = pascal(model);
+        const base = baseSchema[model]?.fields ?? {};
+        const pluginsForModel = pluginAdds[model] ?? {};
+        const pluginIds = Object.keys(pluginsForModel);
+        if (Object.keys(base).length) {
+            out += `export type Base${P}Fields = {\n`;
+            for (const [k, f] of Object.entries(base))out += `  ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type)}\n`;
+            out += '}\n\n';
+        }
+        const needPluginMap = pluginIds.length > 1 || Object.keys(base).length;
+        if (needPluginMap && pluginIds.length) {
+            out += `export type ${P}PluginFields = {\n`;
+            for (const [pid, flds] of Object.entries(pluginsForModel)){
+                out += `  ${JSON.stringify(pid)}: {\n`;
+                for (const [k, f] of Object.entries(flds))out += `    ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type)}\n`;
+                out += '  }\n';
+            }
+            out += '}\n\n';
+        }
+        if (!Object.keys(base).length && pluginIds.length === 1) {
+            const only = pluginIds[0];
+            out += `export type ${P}Fields = {\n`;
+            for (const [k, f] of Object.entries(pluginsForModel[only]))out += `  ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type)}\n`;
+            out += '}\n\n';
+            out += `export type ${P} = ${P}Fields\n\n`;
+            continue;
+        }
+        const parts = [];
+        if (Object.keys(base).length) parts.push(`Base${P}Fields`);
+        if (pluginIds.length) {
+            const mapName = needPluginMap ? `${P}PluginFields` : undefined;
+            parts.push(...pluginIds.map((id)=>mapName ? `${mapName}[${JSON.stringify(id)}]` : 'never'));
+        }
+        out += `export type ${P} = ${parts.join(' & ')}\n\n`;
+    }
+    return out;
+};
+const generated = gen();
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+(async ()=>{
+    const file = path.resolve(__dirname, '../generated-types.ts');
+    await fs.writeFile(file, generated, 'utf8');
+    console.log(`Generated types written to ${file}`);
+})();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/scripts/generate-types.ts"],"sourcesContent":["import { stripe } from '@better-auth/stripe'\nimport { emailHarmony, phoneHarmony } from 'better-auth-harmony'\nimport { getSchema } from 'better-auth/db'\nimport type { FieldAttribute } from 'better-auth/db'\nimport {\n  admin,\n  anonymous,\n  apiKey,\n  bearer,\n  emailOTP,\n  genericOAuth,\n  jwt,\n  magicLink,\n  multiSession,\n  oneTap,\n  oneTimeToken,\n  openAPI,\n  organization,\n  oidcProvider,\n  phoneNumber,\n  twoFactor,\n  username\n} from 'better-auth/plugins'\nimport { passkey } from 'better-auth/plugins/passkey'\nimport { sso } from 'better-auth/plugins/sso'\nimport { polar } from '@polar-sh/better-auth'\nimport { Polar } from '@polar-sh/sdk'\nimport type { SanitizedBetterAuthOptions } from '../types'\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst client = new Polar({\n  accessToken: 'pk_test_1234567890',\n  server: 'sandbox'\n});\n\nconst plugins = [\n  username(),\n  admin(),\n  apiKey(),\n  passkey(),\n  emailHarmony(),\n  phoneHarmony(),\n  bearer(),\n  emailOTP({ sendVerificationOTP: async () => {} }),\n  magicLink({ sendMagicLink: async () => {} }),\n  phoneNumber({ sendOTP: async () => {} }),\n  oneTap(),\n  anonymous(),\n  multiSession(),\n  oneTimeToken(),\n  oidcProvider({ loginPage: '' }),\n  sso(),\n  genericOAuth({ config: [{ providerId: 'typescript', clientId: 'typescript', clientSecret: 'typescript' }] }),\n  openAPI(),\n  organization({ teams: { enabled: true } }),\n  jwt(),\n  twoFactor(),\n  phoneNumber(),\n  stripe({\n    stripeClient: { apiKey: 'typescript' },\n    stripeWebhookSecret: 'typescript',\n    subscription: {\n      enabled: true,\n      plans: [\n        { id: 'basic', name: 'Basic', price: 1000, interval: 'month', currency: 'usd' },\n        { id: 'pro', name: 'Pro', price: 2000, interval: 'month', currency: 'usd' },\n        { id: 'enterprise', name: 'Enterprise', price: 3000, interval: 'month', currency: 'usd' }\n      ]\n    }\n  }),\n  // As of writing this, Polar don't create schema fields, but just in case in the future we leave this here.\n  polar({\n    client,\n    checkout: {\n      enabled: true,\n      products: [\n        { productId: 'basic', slug: 'basic' },\n        { productId: 'pro', slug: 'pro' },\n        { productId: 'enterprise', slug: 'enterprise' }\n      ]\n    }\n  })\n]\n\nconst betterAuthConfig: SanitizedBetterAuthOptions = {\n  emailAndPassword: { enabled: true },\n  user: { additionalFields: { role: { type: 'string', defaultValue: 'user', input: false } } },\n  plugins\n}\n\nconst baseSchema = getSchema({ ...betterAuthConfig, plugins: [] })\n\ntype Schema = Record<string, { fields: Record<string, FieldAttribute> }>\n\nconst map = (t: string): string => {\n  if (t === 'boolean') return 'boolean'\n  if (t === 'date') return 'Date'\n  if (t === 'number') return 'number'\n  if (t === 'string') return 'string'\n  if (t === 'number[]') return 'number[]'\n  if (t === 'string[]') return 'string[]'\n  return 'unknown'\n}\n\nconst pascal = (s: string): string =>\n  s\n    .split(/[-_]/g)\n    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))\n    .join('')\n\nconst diff = (base: Schema, target: Schema): Record<string, Record<string, FieldAttribute>> => {\n  const d: Record<string, Record<string, FieldAttribute>> = {}\n  for (const [m, { fields }] of Object.entries(target)) {\n    const added = Object.entries(fields).filter(([k]) => !(k in (base[m]?.fields ?? {})))\n    if (added.length) d[m] = Object.fromEntries(added)\n  }\n  return d\n}\n\nconst gen = (): string => {\n  let out = '// Auto-generated types. Do not edit.\\n\\n'\n\n  const pluginAdds: Record<string, Record<string, Record<string, FieldAttribute>>> = {}\n  const seen = new Set<string>()\n\n  for (const pl of plugins) {\n    const id = (pl as any).id as string | undefined\n    if (!id || seen.has(id)) continue\n    seen.add(id)\n    const adds = diff(baseSchema, getSchema({ ...betterAuthConfig, plugins: [pl] }))\n    for (const [m, f] of Object.entries(adds)) {\n      pluginAdds[m] ??= {}\n      pluginAdds[m][id] = f\n    }\n  }\n\n  const models = new Set<string>([...Object.keys(baseSchema), ...Object.keys(pluginAdds)])\n\n  for (const model of models) {\n    const P = pascal(model)\n    const base = baseSchema[model]?.fields ?? {}\n    const pluginsForModel = pluginAdds[model] ?? {}\n    const pluginIds = Object.keys(pluginsForModel)\n\n    if (Object.keys(base).length) {\n      out += `export type Base${P}Fields = {\\n`\n      for (const [k, f] of Object.entries(base)) out += `  ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type as string)}\\n`\n      out += '}\\n\\n'\n    }\n\n    const needPluginMap = pluginIds.length > 1 || Object.keys(base).length\n    if (needPluginMap && pluginIds.length) {\n      out += `export type ${P}PluginFields = {\\n`\n      for (const [pid, flds] of Object.entries(pluginsForModel)) {\n        out += `  ${JSON.stringify(pid)}: {\\n`\n        for (const [k, f] of Object.entries(flds)) out += `    ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type as string)}\\n`\n        out += '  }\\n'\n      }\n      out += '}\\n\\n'\n    }\n\n    if (!Object.keys(base).length && pluginIds.length === 1) {\n      const only = pluginIds[0]\n      out += `export type ${P}Fields = {\\n`\n      for (const [k, f] of Object.entries(pluginsForModel[only]))\n        out += `  ${f.fieldName ?? k}${f.required ? '' : '?'}: ${map(f.type as string)}\\n`\n      out += '}\\n\\n'\n      out += `export type ${P} = ${P}Fields\\n\\n`\n      continue\n    }\n\n    const parts: string[] = []\n    if (Object.keys(base).length) parts.push(`Base${P}Fields`)\n    if (pluginIds.length) {\n      const mapName = needPluginMap ? `${P}PluginFields` : undefined\n      parts.push(...pluginIds.map((id) => (mapName ? `${mapName}[${JSON.stringify(id)}]` : 'never') /* not reachable */))\n    }\n    out += `export type ${P} = ${parts.join(' & ')}\\n\\n`\n  }\n\n  return out\n}\n\nconst generated = gen()\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url))\n;(async () => {\n  const file = path.resolve(__dirname, '../generated-types.ts')\n  await fs.writeFile(file, generated, 'utf8')\n  console.log(`Generated types written to ${file}`)\n})()\n"],"names":["stripe","emailHarmony","phoneHarmony","getSchema","admin","anonymous","apiKey","bearer","emailOTP","genericOAuth","jwt","magicLink","multiSession","oneTap","oneTimeToken","openAPI","organization","oidcProvider","phoneNumber","twoFactor","username","passkey","sso","polar","Polar","fs","path","fileURLToPath","client","accessToken","server","plugins","sendVerificationOTP","sendMagicLink","sendOTP","loginPage","config","providerId","clientId","clientSecret","teams","enabled","stripeClient","stripeWebhookSecret","subscription","plans","id","name","price","interval","currency","checkout","products","productId","slug","betterAuthConfig","emailAndPassword","user","additionalFields","role","type","defaultValue","input","baseSchema","map","t","pascal","s","split","p","charAt","toUpperCase","slice","join","diff","base","target","d","m","fields","Object","entries","added","filter","k","length","fromEntries","gen","out","pluginAdds","seen","Set","pl","has","add","adds","f","models","keys","model","P","pluginsForModel","pluginIds","fieldName","required","needPluginMap","pid","flds","JSON","stringify","only","parts","push","mapName","undefined","generated","__dirname","dirname","url","file","resolve","writeFile","console","log"],"mappings":"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"}

package/dist/shared/form/validation.d.ts

@@ -70,34 +70,58 @@ export declare const createLoginSchema: ({ t, loginType, canLoginWithUsername, u
     password: string;
     login: string;
 }>;
-export declare const createSignupSchema: ({ t, requireUsername }: {
+export declare const createSignupSchema: ({ t, requireUsername, requireConfirmPassword }: {
     t: Translate;
     requireUsername?: boolean;
-}) => z.ZodEffects<z.ZodObject<{
+    requireConfirmPassword?: boolean;
+}) => z.ZodObject<{
+    name: z.ZodString;
     email: z.ZodEffects<z.ZodString, string, string>;
     username: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     password: z.ZodString;
-    confirmPassword: z.ZodString;
+    confirmPassword: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    name: string;
     email: string;
     password: string;
-    confirmPassword: string;
     username?: string | undefined;
+    confirmPassword?: string | undefined;
 }, {
+    name: string;
+    email: string;
+    password: string;
+    username?: string | undefined;
+    confirmPassword?: string | undefined;
+}> | z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodEffects<z.ZodString, string, string>;
+    username: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    password: z.ZodString;
+    confirmPassword: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
     email: string;
     password: string;
-    confirmPassword: string;
     username?: string | undefined;
+    confirmPassword?: string | undefined;
+}, {
+    name: string;
+    email: string;
+    password: string;
+    username?: string | undefined;
+    confirmPassword?: string | undefined;
 }>, {
+    name: string;
     email: string;
     password: string;
-    confirmPassword: string;
     username?: string | undefined;
+    confirmPassword?: string | undefined;
 }, {
+    name: string;
     email: string;
     password: string;
-    confirmPassword: string;
     username?: string | undefined;
+    confirmPassword?: string | undefined;
 }>;
 export {};
 //# sourceMappingURL=validation.d.ts.map

package/dist/shared/form/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/shared/form/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAA;AAMlD,eAAO,MAAM,UAAU,GAAI,iBAAwB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,8CAMtF,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,uCAK3B;IACD,CAAC,EAAE,SAAS,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,8CAMA,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,4BAAuC;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,gBAI5H,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,iBAAwB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,gBAIhG,CAAA;AAMD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,kBAAsB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;EAS7F,CAAA;AAMN,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,YAAyB,CAAA;AACjE,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,2BAAoC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,YACjD,CAAA;AAM/E,KAAK,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhE,eAAO,MAAM,iBAAiB,GAAI,0DAK/B;IACD,CAAC,EAAE,SAAS,CAAA;IACZ,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,iBAAiB,CAAA;IACnD,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;CACpC;;;;;;;;;EA8BG,CAAA;AAEJ,eAAO,MAAM,kBAAkB,GAAI,wBAAgC;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAWxG,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/shared/form/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAA;AAMlD,eAAO,MAAM,UAAU,GAAI,iBAAwB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,8CAMtF,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,uCAK3B;IACD,CAAC,EAAE,SAAS,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,8CAMA,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,4BAAuC;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,gBAI5H,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,iBAAwB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,gBAIhG,CAAA;AAMD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,kBAAsB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;EAS7F,CAAA;AAMN,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,YAAyB,CAAA;AACjE,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,2BAAoC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,YACjD,CAAA;AAM/E,KAAK,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhE,eAAO,MAAM,iBAAiB,GAAI,0DAK/B;IACD,CAAC,EAAE,SAAS,CAAA;IACZ,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,iBAAiB,CAAA;IACnD,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;CACpC;;;;;;;;;EA8BG,CAAA;AAEJ,eAAO,MAAM,kBAAkB,GAAI,gDAAgE;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,sBAAsB,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe/K,CAAA"}

package/dist/shared/form/validation.js

@@ -84,7 +84,11 @@ export const createLoginSchema = ({ t, loginType, canLoginWithUsername = false,
             t
         })
     });
-export const createSignupSchema = ({ t, requireUsername = false })=>z.object({
+export const createSignupSchema = ({ t, requireUsername = false, requireConfirmPassword = false })=>{
+    const schema = z.object({
+        name: z.string({
+            message: 'Name is required'
+        }).min(1),
         email: emailField({
             t
         }),
@@ -96,13 +100,17 @@ export const createSignupSchema = ({ t, requireUsername = false })=>z.object({
             t
         }),
         confirmPassword: confirmPasswordField({
-            t
-        })
-    }).refine((data)=>data.password === data.confirmPassword, {
+            t,
+            required: requireConfirmPassword
+        }).optional()
+    });
+    if (!requireConfirmPassword) return schema;
+    return schema.refine((data)=>data.password === data.confirmPassword, {
         path: [
             'confirmPassword'
         ],
         message: t('fields:passwordsDoNotMatch') || 'Passwords do not match'
     });
+};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/shared/form/validation.ts"],"sourcesContent":["import { z } from 'zod'\n\nimport { emailRegex, usernameRegex } from '@/shared/utils/regex'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Minimal translation function type extracted from `i18next`.\n * Accepts a key and returns the translated string.\n */\nexport type Translate = (...args: any[]) => string\n\n// ---------------------------------------------------------------------------\n// Field builders\n// ---------------------------------------------------------------------------\n\nexport const emailField = ({ t, required = true }: { t: Translate; required?: boolean }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required'))\n  return schema.refine((val) => emailRegex.test(val), {\n    message: t('authentication:emailNotValid') || 'Email is not valid'\n  })\n}\n\nexport const usernameField = ({\n  t,\n  required = true,\n  minLength = 5,\n  maxLength = 128\n}: {\n  t: Translate\n  required?: boolean\n  minLength?: number\n  maxLength?: number\n}) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required'))\n  return schema.refine((val) => usernameRegex.test(val) && val.length >= minLength && val.length <= maxLength, {\n    message: t('authentication:usernameNotValid') || 'Username is not valid'\n  })\n}\n\nexport const passwordField = ({ t, required = true, minLength = 1 }: { t: Translate; required?: boolean; minLength?: number }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(minLength, t('validation:required') || 'Password is required')\n  return schema\n}\n\nexport const confirmPasswordField = ({ t, required = true }: { t: Translate; required?: boolean }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required') || 'Confirm password is required')\n  return schema\n}\n\n// ---------------------------------------------------------------------------\n// Composables\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a Zod object schema with `password` and `confirmPassword` fields\n * and a refinement that ensures they match.\n */\nexport const passwordWithConfirmation = ({ t, minLength = 1 }: { t: Translate; minLength?: number }) =>\n  z\n    .object({\n      password: passwordField({ t, minLength }),\n      confirmPassword: confirmPasswordField({ t })\n    })\n    .refine((data) => data.password === data.confirmPassword, {\n      path: ['confirmPassword'],\n      message: t('fields:passwordsDoNotMatch') || 'Passwords do not match'\n    })\n\n// ---------------------------------------------------------------------------\n// Utility validators (non‑Zod) — handy for dynamic login field checks\n// ---------------------------------------------------------------------------\n\nexport const isValidEmail = (val: string) => emailRegex.test(val)\nexport const isValidUsername = (val: string, { minLength = 5, maxLength = 128 }: { minLength?: number; maxLength?: number } = {}) =>\n  usernameRegex.test(val) && val.length >= minLength && val.length <= maxLength\n\n// ---------------------------------------------------------------------------\n// Schema builders\n// ---------------------------------------------------------------------------\n\ntype UsernameSettings = { minLength: number; maxLength: number }\n\nexport const createLoginSchema = ({\n  t,\n  loginType,\n  canLoginWithUsername = false,\n  usernameSettings = { minLength: 5, maxLength: 128 }\n}: {\n  t: Translate\n  loginType: 'email' | 'username' | 'emailOrUsername'\n  canLoginWithUsername?: boolean\n  usernameSettings?: UsernameSettings\n}) =>\n  z.object({\n    login: z.string().refine(\n      (val) => {\n        if (!val) return false\n        if (loginType === 'email') return isValidEmail(val)\n        if (loginType === 'username') return isValidUsername(val, usernameSettings)\n        return isValidEmail(val) || isValidUsername(val, usernameSettings)\n      },\n      (val) => {\n        if (!val) return { message: t('validation:required') }\n\n        const isProbablyEmail = val.includes('@') || !canLoginWithUsername\n\n        if (loginType === 'email') {\n          return { message: t('authentication:emailNotValid') || 'Email is not valid' }\n        }\n\n        if (loginType === 'username') {\n          return { message: t('authentication:usernameNotValid') || 'Username is not valid' }\n        }\n\n        return {\n          message: isProbablyEmail\n            ? t('authentication:emailNotValid') || 'Email is not valid'\n            : t('authentication:usernameNotValid') || 'Username is not valid'\n        }\n      }\n    ),\n    password: passwordField({ t })\n  })\n\nexport const createSignupSchema = ({ t, requireUsername = false }: { t: Translate; requireUsername?: boolean }) =>\n  z\n    .object({\n      email: emailField({ t }),\n      username: usernameField({ t, required: requireUsername }).optional(),\n      password: passwordField({ t }),\n      confirmPassword: confirmPasswordField({ t })\n    })\n    .refine((data) => data.password === data.confirmPassword, {\n      path: ['confirmPassword'],\n      message: t('fields:passwordsDoNotMatch') || 'Passwords do not match'\n    })\n"],"names":["z","emailRegex","usernameRegex","emailField","t","required","schema","string","min","refine","val","test","message","usernameField","minLength","maxLength","length","passwordField","confirmPasswordField","passwordWithConfirmation","object","password","confirmPassword","data","path","isValidEmail","isValidUsername","createLoginSchema","loginType","canLoginWithUsername","usernameSettings","login","isProbablyEmail","includes","createSignupSchema","requireUsername","email","username","optional"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/shared/form/validation.ts"],"sourcesContent":["import { z } from 'zod'\n\nimport { emailRegex, usernameRegex } from '@/shared/utils/regex'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Minimal translation function type extracted from `i18next`.\n * Accepts a key and returns the translated string.\n */\nexport type Translate = (...args: any[]) => string\n\n// ---------------------------------------------------------------------------\n// Field builders\n// ---------------------------------------------------------------------------\n\nexport const emailField = ({ t, required = true }: { t: Translate; required?: boolean }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required'))\n  return schema.refine((val) => emailRegex.test(val), {\n    message: t('authentication:emailNotValid') || 'Email is not valid'\n  })\n}\n\nexport const usernameField = ({\n  t,\n  required = true,\n  minLength = 5,\n  maxLength = 128\n}: {\n  t: Translate\n  required?: boolean\n  minLength?: number\n  maxLength?: number\n}) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required'))\n  return schema.refine((val) => usernameRegex.test(val) && val.length >= minLength && val.length <= maxLength, {\n    message: t('authentication:usernameNotValid') || 'Username is not valid'\n  })\n}\n\nexport const passwordField = ({ t, required = true, minLength = 1 }: { t: Translate; required?: boolean; minLength?: number }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(minLength, t('validation:required') || 'Password is required')\n  return schema\n}\n\nexport const confirmPasswordField = ({ t, required = true }: { t: Translate; required?: boolean }) => {\n  let schema = z.string()\n  if (required) schema = schema.min(1, t('validation:required') || 'Confirm password is required')\n  return schema\n}\n\n// ---------------------------------------------------------------------------\n// Composables\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a Zod object schema with `password` and `confirmPassword` fields\n * and a refinement that ensures they match.\n */\nexport const passwordWithConfirmation = ({ t, minLength = 1 }: { t: Translate; minLength?: number }) =>\n  z\n    .object({\n      password: passwordField({ t, minLength }),\n      confirmPassword: confirmPasswordField({ t })\n    })\n    .refine((data) => data.password === data.confirmPassword, {\n      path: ['confirmPassword'],\n      message: t('fields:passwordsDoNotMatch') || 'Passwords do not match'\n    })\n\n// ---------------------------------------------------------------------------\n// Utility validators (non‑Zod) — handy for dynamic login field checks\n// ---------------------------------------------------------------------------\n\nexport const isValidEmail = (val: string) => emailRegex.test(val)\nexport const isValidUsername = (val: string, { minLength = 5, maxLength = 128 }: { minLength?: number; maxLength?: number } = {}) =>\n  usernameRegex.test(val) && val.length >= minLength && val.length <= maxLength\n\n// ---------------------------------------------------------------------------\n// Schema builders\n// ---------------------------------------------------------------------------\n\ntype UsernameSettings = { minLength: number; maxLength: number }\n\nexport const createLoginSchema = ({\n  t,\n  loginType,\n  canLoginWithUsername = false,\n  usernameSettings = { minLength: 5, maxLength: 128 }\n}: {\n  t: Translate\n  loginType: 'email' | 'username' | 'emailOrUsername'\n  canLoginWithUsername?: boolean\n  usernameSettings?: UsernameSettings\n}) =>\n  z.object({\n    login: z.string().refine(\n      (val) => {\n        if (!val) return false\n        if (loginType === 'email') return isValidEmail(val)\n        if (loginType === 'username') return isValidUsername(val, usernameSettings)\n        return isValidEmail(val) || isValidUsername(val, usernameSettings)\n      },\n      (val) => {\n        if (!val) return { message: t('validation:required') }\n\n        const isProbablyEmail = val.includes('@') || !canLoginWithUsername\n\n        if (loginType === 'email') {\n          return { message: t('authentication:emailNotValid') || 'Email is not valid' }\n        }\n\n        if (loginType === 'username') {\n          return { message: t('authentication:usernameNotValid') || 'Username is not valid' }\n        }\n\n        return {\n          message: isProbablyEmail\n            ? t('authentication:emailNotValid') || 'Email is not valid'\n            : t('authentication:usernameNotValid') || 'Username is not valid'\n        }\n      }\n    ),\n    password: passwordField({ t })\n  })\n\nexport const createSignupSchema = ({ t, requireUsername = false, requireConfirmPassword = false }: { t: Translate; requireUsername?: boolean; requireConfirmPassword?: boolean }) => {\n  const schema = z.object({\n    name: z.string({ message: 'Name is required' }).min(1),\n    email: emailField({ t }),\n    username: usernameField({ t, required: requireUsername }).optional(),\n    password: passwordField({ t }),\n    confirmPassword: confirmPasswordField({ t, required: requireConfirmPassword }).optional()\n  })\n\n  if (!requireConfirmPassword) return schema\n\n  return schema.refine((data) => data.password === data.confirmPassword, {\n    path: ['confirmPassword'],\n    message: t('fields:passwordsDoNotMatch') || 'Passwords do not match'\n  })\n}\n"],"names":["z","emailRegex","usernameRegex","emailField","t","required","schema","string","min","refine","val","test","message","usernameField","minLength","maxLength","length","passwordField","confirmPasswordField","passwordWithConfirmation","object","password","confirmPassword","data","path","isValidEmail","isValidUsername","createLoginSchema","loginType","canLoginWithUsername","usernameSettings","login","isProbablyEmail","includes","createSignupSchema","requireUsername","requireConfirmPassword","name","email","username","optional"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payload-auth",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -75,9 +75,11 @@
   "scripts": {
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo",
     "build": "pnpm clean && pnpm copyfiles && pnpm build:types && pnpm build:swc",
-    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist",
+    "copyfiles": "copyfiles -u 1 --exclude \"src/better-auth/adapter/tests/**/*\" \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist",
     "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
-    "build:types": "tsc --project tsconfig.json"
+    "build:types": "pnpm generate:better-auth-types && tsc --project tsconfig.json",
+    "test": "vitest",
+    "generate:better-auth-types": "rm -rf src/better-auth/generated-types.ts && tsx src/better-auth/scripts/generate-types.ts"
   },
   "peerDependencies": {
     "@payloadcms/ui": "3.35.1",
@@ -89,25 +91,33 @@
   },
   "devDependencies": {
     "@clerk/types": "^4.50.1",
+    "@payloadcms/db-postgres": "3.35.1",
     "@swc/cli": "0.6.0",
     "@swc/core": "1.11.13",
     "@types/node": "^20.0.0",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "copyfiles": "^2.4.1",
+    "cross-env": "^7.0.3",
+    "dotenv": "^16.5.0",
+    "payload": "^3.35",
+    "tsx": "^4.19.4",
     "typescript": "5.8.2",
     "vitest": "^1.0.0"
   },
   "dependencies": {
+    "@better-auth/stripe": "1.2.7",
     "@better-auth/utils": "0.2.4",
     "@clerk/backend": "^1.25.8",
     "@clerk/clerk-js": "^5.58.1",
     "@clerk/nextjs": "^6.12.12",
+    "@polar-sh/better-auth": "^0.1.1",
+    "@polar-sh/sdk": "^0.32.13",
     "@tanstack/react-form": "1.4.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "jose": "^6.0.10",
-    "lucide-react": "0.482.0",
+    "lucide-react": "0.503.0",
     "qrcode.react": "^4.2.0",
     "sonner": "2.0.1",
     "svix": "^1.62.0",

package/dist/better-auth/plugin/helpers/check-passkey-plugin.d.ts

@@ -1,3 +0,0 @@
-import type { SanitizedBetterAuthOptions } from '../types';
-export declare function checkPasskeyPlugin(options: SanitizedBetterAuthOptions): boolean;
-//# sourceMappingURL=check-passkey-plugin.d.ts.map

package/dist/better-auth/plugin/helpers/check-passkey-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-passkey-plugin.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/check-passkey-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAA;AAE1D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,0BAA0B,WAErE"}

package/dist/better-auth/plugin/helpers/check-passkey-plugin.js

@@ -1,6 +0,0 @@
-import { supportedBetterAuthPluginIds } from "../constants";
-export function checkPasskeyPlugin(options) {
-    return options.plugins?.some((plugin)=>plugin.id === supportedBetterAuthPluginIds.passkey) || false;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9jaGVjay1wYXNza2V5LXBsdWdpbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzdXBwb3J0ZWRCZXR0ZXJBdXRoUGx1Z2luSWRzIH0gZnJvbSAnLi4vY29uc3RhbnRzJ1xuaW1wb3J0IHR5cGUgeyBTYW5pdGl6ZWRCZXR0ZXJBdXRoT3B0aW9ucyB9IGZyb20gJy4uL3R5cGVzJ1xuXG5leHBvcnQgZnVuY3Rpb24gY2hlY2tQYXNza2V5UGx1Z2luKG9wdGlvbnM6IFNhbml0aXplZEJldHRlckF1dGhPcHRpb25zKSB7XG4gIHJldHVybiBvcHRpb25zLnBsdWdpbnM/LnNvbWUoKHBsdWdpbikgPT4gcGx1Z2luLmlkID09PSBzdXBwb3J0ZWRCZXR0ZXJBdXRoUGx1Z2luSWRzLnBhc3NrZXkpIHx8IGZhbHNlXG59XG4iXSwibmFtZXMiOlsic3VwcG9ydGVkQmV0dGVyQXV0aFBsdWdpbklkcyIsImNoZWNrUGFzc2tleVBsdWdpbiIsIm9wdGlvbnMiLCJwbHVnaW5zIiwic29tZSIsInBsdWdpbiIsImlkIiwicGFzc2tleSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsNEJBQTRCLFFBQVEsZUFBYztBQUczRCxPQUFPLFNBQVNDLG1CQUFtQkMsT0FBbUM7SUFDcEUsT0FBT0EsUUFBUUMsT0FBTyxFQUFFQyxLQUFLLENBQUNDLFNBQVdBLE9BQU9DLEVBQUUsS0FBS04sNkJBQTZCTyxPQUFPLEtBQUs7QUFDbEcifQ==

package/dist/better-auth/plugin/helpers/check-two-factor-plugin.d.ts

@@ -1,3 +0,0 @@
-import type { SanitizedBetterAuthOptions } from '../types';
-export declare function checkTwoFactorPlugin(options: SanitizedBetterAuthOptions): boolean;
-//# sourceMappingURL=check-two-factor-plugin.d.ts.map

package/dist/better-auth/plugin/helpers/check-two-factor-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-two-factor-plugin.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/check-two-factor-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAA;AAE1D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,0BAA0B,WAEvE"}