payload-auth 1.4.0 → 1.5.0

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

@@ -0,0 +1,14 @@
+/**
+ * Checks if a plugin with the specified ID exists in the Better Auth options
+ *
+ * This utility function examines the plugins array in the provided Better Auth options
+ * to determine if a plugin with the given ID is already registered.
+ *
+ * @param options - The Better Auth configuration options
+ * @param pluginId - The unique identifier of the plugin to check for
+ * @returns `true` if a plugin with the specified ID exists, `false` otherwise
+ */ export function checkPluginExists(options, pluginId) {
+    return options.plugins?.some((plugin)=>plugin.id === pluginId) || false;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9jaGVjay1wbHVnaW4tZXhpc3RzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQmV0dGVyQXV0aE9wdGlvbnMgfSBmcm9tICcuLi90eXBlcydcblxuLyoqXG4gKiBDaGVja3MgaWYgYSBwbHVnaW4gd2l0aCB0aGUgc3BlY2lmaWVkIElEIGV4aXN0cyBpbiB0aGUgQmV0dGVyIEF1dGggb3B0aW9uc1xuICpcbiAqIFRoaXMgdXRpbGl0eSBmdW5jdGlvbiBleGFtaW5lcyB0aGUgcGx1Z2lucyBhcnJheSBpbiB0aGUgcHJvdmlkZWQgQmV0dGVyIEF1dGggb3B0aW9uc1xuICogdG8gZGV0ZXJtaW5lIGlmIGEgcGx1Z2luIHdpdGggdGhlIGdpdmVuIElEIGlzIGFscmVhZHkgcmVnaXN0ZXJlZC5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSBCZXR0ZXIgQXV0aCBjb25maWd1cmF0aW9uIG9wdGlvbnNcbiAqIEBwYXJhbSBwbHVnaW5JZCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBvZiB0aGUgcGx1Z2luIHRvIGNoZWNrIGZvclxuICogQHJldHVybnMgYHRydWVgIGlmIGEgcGx1Z2luIHdpdGggdGhlIHNwZWNpZmllZCBJRCBleGlzdHMsIGBmYWxzZWAgb3RoZXJ3aXNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjaGVja1BsdWdpbkV4aXN0cyhvcHRpb25zOiBCZXR0ZXJBdXRoT3B0aW9ucywgcGx1Z2luSWQ6IHN0cmluZyk6IGJvb2xlYW4ge1xuICByZXR1cm4gb3B0aW9ucy5wbHVnaW5zPy5zb21lKChwbHVnaW4pID0+IHBsdWdpbi5pZCA9PT0gcGx1Z2luSWQpIHx8IGZhbHNlXG59XG4iXSwibmFtZXMiOlsiY2hlY2tQbHVnaW5FeGlzdHMiLCJvcHRpb25zIiwicGx1Z2luSWQiLCJwbHVnaW5zIiwic29tZSIsInBsdWdpbiIsImlkIl0sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7Ozs7O0NBU0MsR0FDRCxPQUFPLFNBQVNBLGtCQUFrQkMsT0FBMEIsRUFBRUMsUUFBZ0I7SUFDNUUsT0FBT0QsUUFBUUUsT0FBTyxFQUFFQyxLQUFLLENBQUNDLFNBQVdBLE9BQU9DLEVBQUUsS0FBS0osYUFBYTtBQUN0RSJ9

package/dist/better-auth/plugin/helpers/get-better-auth-schema.d.ts

@@ -0,0 +1,22 @@
+import { type FieldAttribute } from 'better-auth/db';
+import type { BetterAuthOptions } from 'better-auth';
+/**
+ * This is a slighlty modfied version of the getSchema function from better-auth.
+ * Found here: https://github.com/better-auth/better-auth/blob/main/packages/better-auth/src/db/get-schema.ts
+ *
+ * We DON'T do this:
+ * actualFields[field.fieldName || key] = field;
+ *
+ * Instead we will do this:
+ * actualFields[key] = field;
+ *
+ * This is to contain consistency when statically hard coded keys.
+ *
+ * @param config - The better auth config
+ * @returns The schema for the better auth tables
+ */
+export declare function getBetterAuthSchema(config: BetterAuthOptions): Record<string, {
+    fields: Record<string, FieldAttribute>;
+    order: number;
+}>;
+//# sourceMappingURL=get-better-auth-schema.d.ts.map

package/dist/better-auth/plugin/helpers/get-better-auth-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-better-auth-schema.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-better-auth-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB;YAK/C,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;WAC/B,MAAM;GAgClB"}

package/dist/better-auth/plugin/helpers/get-better-auth-schema.js

@@ -0,0 +1,50 @@
+import { getAuthTables } from "better-auth/db";
+/**
+ * This is a slighlty modfied version of the getSchema function from better-auth.
+ * Found here: https://github.com/better-auth/better-auth/blob/main/packages/better-auth/src/db/get-schema.ts
+ *
+ * We DON'T do this:
+ * actualFields[field.fieldName || key] = field;
+ *
+ * Instead we will do this:
+ * actualFields[key] = field;
+ *
+ * This is to contain consistency when statically hard coded keys.
+ *
+ * @param config - The better auth config
+ * @returns The schema for the better auth tables
+ */ export function getBetterAuthSchema(config) {
+    const tables = getAuthTables(config);
+    let schema = {};
+    for(const key in tables){
+        const table = tables[key];
+        const fields = table.fields;
+        let actualFields = {};
+        Object.entries(fields).forEach(([key, field])=>{
+            actualFields[key] = field;
+            if (field.references) {
+                const refTable = tables[field.references.model];
+                if (refTable) {
+                    actualFields[key].references = {
+                        model: refTable.modelName,
+                        field: field.references.field
+                    };
+                }
+            }
+        });
+        if (schema[table.modelName]) {
+            schema[table.modelName].fields = {
+                ...schema[table.modelName].fields,
+                ...actualFields
+            };
+            continue;
+        }
+        schema[table.modelName] = {
+            fields: actualFields,
+            order: table.order || Infinity
+        };
+    }
+    return schema;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9nZXQtYmV0dGVyLWF1dGgtc2NoZW1hLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldEF1dGhUYWJsZXMsIHR5cGUgRmllbGRBdHRyaWJ1dGUgfSBmcm9tICdiZXR0ZXItYXV0aC9kYidcbmltcG9ydCB0eXBlIHsgQmV0dGVyQXV0aE9wdGlvbnMgfSBmcm9tICdiZXR0ZXItYXV0aCdcblxuLyoqXG4gKiBUaGlzIGlzIGEgc2xpZ2hsdHkgbW9kZmllZCB2ZXJzaW9uIG9mIHRoZSBnZXRTY2hlbWEgZnVuY3Rpb24gZnJvbSBiZXR0ZXItYXV0aC5cbiAqIEZvdW5kIGhlcmU6IGh0dHBzOi8vZ2l0aHViLmNvbS9iZXR0ZXItYXV0aC9iZXR0ZXItYXV0aC9ibG9iL21haW4vcGFja2FnZXMvYmV0dGVyLWF1dGgvc3JjL2RiL2dldC1zY2hlbWEudHNcbiAqXG4gKiBXZSBET04nVCBkbyB0aGlzOlxuICogYWN0dWFsRmllbGRzW2ZpZWxkLmZpZWxkTmFtZSB8fCBrZXldID0gZmllbGQ7XG4gKlxuICogSW5zdGVhZCB3ZSB3aWxsIGRvIHRoaXM6XG4gKiBhY3R1YWxGaWVsZHNba2V5XSA9IGZpZWxkO1xuICpcbiAqIFRoaXMgaXMgdG8gY29udGFpbiBjb25zaXN0ZW5jeSB3aGVuIHN0YXRpY2FsbHkgaGFyZCBjb2RlZCBrZXlzLlxuICpcbiAqIEBwYXJhbSBjb25maWcgLSBUaGUgYmV0dGVyIGF1dGggY29uZmlnXG4gKiBAcmV0dXJucyBUaGUgc2NoZW1hIGZvciB0aGUgYmV0dGVyIGF1dGggdGFibGVzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRCZXR0ZXJBdXRoU2NoZW1hKGNvbmZpZzogQmV0dGVyQXV0aE9wdGlvbnMpIHtcbiAgY29uc3QgdGFibGVzID0gZ2V0QXV0aFRhYmxlcyhjb25maWcpXG4gIGxldCBzY2hlbWE6IFJlY29yZDxcbiAgICBzdHJpbmcsXG4gICAge1xuICAgICAgZmllbGRzOiBSZWNvcmQ8c3RyaW5nLCBGaWVsZEF0dHJpYnV0ZT5cbiAgICAgIG9yZGVyOiBudW1iZXJcbiAgICB9XG4gID4gPSB7fVxuICBmb3IgKGNvbnN0IGtleSBpbiB0YWJsZXMpIHtcbiAgICBjb25zdCB0YWJsZSA9IHRhYmxlc1trZXldXG4gICAgY29uc3QgZmllbGRzID0gdGFibGUuZmllbGRzXG4gICAgbGV0IGFjdHVhbEZpZWxkczogUmVjb3JkPHN0cmluZywgRmllbGRBdHRyaWJ1dGU+ID0ge31cbiAgICBPYmplY3QuZW50cmllcyhmaWVsZHMpLmZvckVhY2goKFtrZXksIGZpZWxkXSkgPT4ge1xuICAgICAgYWN0dWFsRmllbGRzW2tleV0gPSBmaWVsZFxuICAgICAgaWYgKGZpZWxkLnJlZmVyZW5jZXMpIHtcbiAgICAgICAgY29uc3QgcmVmVGFibGUgPSB0YWJsZXNbZmllbGQucmVmZXJlbmNlcy5tb2RlbF1cbiAgICAgICAgaWYgKHJlZlRhYmxlKSB7XG4gICAgICAgICAgYWN0dWFsRmllbGRzW2tleV0ucmVmZXJlbmNlcyA9IHtcbiAgICAgICAgICAgIG1vZGVsOiByZWZUYWJsZS5tb2RlbE5hbWUsXG4gICAgICAgICAgICBmaWVsZDogZmllbGQucmVmZXJlbmNlcy5maWVsZFxuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfVxuICAgIH0pXG4gICAgaWYgKHNjaGVtYVt0YWJsZS5tb2RlbE5hbWVdKSB7XG4gICAgICBzY2hlbWFbdGFibGUubW9kZWxOYW1lXS5maWVsZHMgPSB7XG4gICAgICAgIC4uLnNjaGVtYVt0YWJsZS5tb2RlbE5hbWVdLmZpZWxkcyxcbiAgICAgICAgLi4uYWN0dWFsRmllbGRzXG4gICAgICB9XG4gICAgICBjb250aW51ZVxuICAgIH1cbiAgICBzY2hlbWFbdGFibGUubW9kZWxOYW1lXSA9IHtcbiAgICAgIGZpZWxkczogYWN0dWFsRmllbGRzLFxuICAgICAgb3JkZXI6IHRhYmxlLm9yZGVyIHx8IEluZmluaXR5XG4gICAgfVxuICB9XG4gIHJldHVybiBzY2hlbWFcbn1cbiJdLCJuYW1lcyI6WyJnZXRBdXRoVGFibGVzIiwiZ2V0QmV0dGVyQXV0aFNjaGVtYSIsImNvbmZpZyIsInRhYmxlcyIsInNjaGVtYSIsImtleSIsInRhYmxlIiwiZmllbGRzIiwiYWN0dWFsRmllbGRzIiwiT2JqZWN0IiwiZW50cmllcyIsImZvckVhY2giLCJmaWVsZCIsInJlZmVyZW5jZXMiLCJyZWZUYWJsZSIsIm1vZGVsIiwibW9kZWxOYW1lIiwib3JkZXIiLCJJbmZpbml0eSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsYUFBYSxRQUE2QixpQkFBZ0I7QUFHbkU7Ozs7Ozs7Ozs7Ozs7O0NBY0MsR0FDRCxPQUFPLFNBQVNDLG9CQUFvQkMsTUFBeUI7SUFDM0QsTUFBTUMsU0FBU0gsY0FBY0U7SUFDN0IsSUFBSUUsU0FNQSxDQUFDO0lBQ0wsSUFBSyxNQUFNQyxPQUFPRixPQUFRO1FBQ3hCLE1BQU1HLFFBQVFILE1BQU0sQ0FBQ0UsSUFBSTtRQUN6QixNQUFNRSxTQUFTRCxNQUFNQyxNQUFNO1FBQzNCLElBQUlDLGVBQStDLENBQUM7UUFDcERDLE9BQU9DLE9BQU8sQ0FBQ0gsUUFBUUksT0FBTyxDQUFDLENBQUMsQ0FBQ04sS0FBS08sTUFBTTtZQUMxQ0osWUFBWSxDQUFDSCxJQUFJLEdBQUdPO1lBQ3BCLElBQUlBLE1BQU1DLFVBQVUsRUFBRTtnQkFDcEIsTUFBTUMsV0FBV1gsTUFBTSxDQUFDUyxNQUFNQyxVQUFVLENBQUNFLEtBQUssQ0FBQztnQkFDL0MsSUFBSUQsVUFBVTtvQkFDWk4sWUFBWSxDQUFDSCxJQUFJLENBQUNRLFVBQVUsR0FBRzt3QkFDN0JFLE9BQU9ELFNBQVNFLFNBQVM7d0JBQ3pCSixPQUFPQSxNQUFNQyxVQUFVLENBQUNELEtBQUs7b0JBQy9CO2dCQUNGO1lBQ0Y7UUFDRjtRQUNBLElBQUlSLE1BQU0sQ0FBQ0UsTUFBTVUsU0FBUyxDQUFDLEVBQUU7WUFDM0JaLE1BQU0sQ0FBQ0UsTUFBTVUsU0FBUyxDQUFDLENBQUNULE1BQU0sR0FBRztnQkFDL0IsR0FBR0gsTUFBTSxDQUFDRSxNQUFNVSxTQUFTLENBQUMsQ0FBQ1QsTUFBTTtnQkFDakMsR0FBR0MsWUFBWTtZQUNqQjtZQUNBO1FBQ0Y7UUFDQUosTUFBTSxDQUFDRSxNQUFNVSxTQUFTLENBQUMsR0FBRztZQUN4QlQsUUFBUUM7WUFDUlMsT0FBT1gsTUFBTVcsS0FBSyxJQUFJQztRQUN4QjtJQUNGO0lBQ0EsT0FBT2Q7QUFDVCJ9

package/dist/better-auth/plugin/helpers/get-collection-schema-map.d.ts

@@ -0,0 +1,16 @@
+import { baModelKey } from '../constants';
+import { BetterAuthPluginOptions } from '../types';
+export type CollectionSchemaMap = Record<keyof typeof baModelKey, {
+    collectionSlug: string;
+    fields: Record<string, string>;
+}>;
+export declare function getDefaultCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap;
+/**
+ * Builds a collection schema map by analyzing collection overrides and extracting
+ * BetterAuth model keys and field mappings
+ *
+ * @param collectionOverrides - Collection override functions provided in plugin options
+ * @returns A collection schema map with default values merged with any overrides
+ */
+export declare function buildCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap;
+//# sourceMappingURL=get-collection-schema-map.d.ts.map

package/dist/better-auth/plugin/helpers/get-collection-schema-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-collection-schema-map.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection-schema-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,UAAU,EAAE,MAAM,cAAc,CAAA;AAQvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAElD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CACtC,MAAM,OAAO,UAAU,EACvB;IACE,cAAc,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B,CACF,CAAA;AAED,wBAAgB,6BAA6B,CAAC,aAAa,EAAE,uBAAuB,GAAG,mBAAmB,CAmCzG;AAMD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,uBAAuB,GAAG,mBAAmB,CA0CpG"}

package/dist/better-auth/plugin/helpers/get-collection-schema-map.js

@@ -0,0 +1,108 @@
+import { baModelFieldKeysToFieldNames, baModelKey } from "../constants";
+import { getAuthTables } from "better-auth/db";
+import { flattenAllFields } from "payload/shared";
+import { getDeafultCollectionSlug } from "./get-collection-slug";
+export function getDefaultCollectionSchemaMap(pluginOptions) {
+    const tables = getAuthTables(pluginOptions.betterAuthOptions ?? {});
+    const map = {};
+    Object.entries(tables).forEach(([key, table])=>{
+        const fieldNames = Object.entries(table.fields).map(([k, v])=>k);
+        const typedKey = key;
+        const value = {
+            collectionSlug: getDeafultCollectionSlug({
+                modelKey: typedKey,
+                pluginOptions
+            }),
+            fields: fieldNames.reduce((acc, field)=>{
+                if (typedKey in baModelFieldKeysToFieldNames && field in baModelFieldKeysToFieldNames[typedKey]) {
+                    const fieldMapping = baModelFieldKeysToFieldNames[typedKey];
+                    const typedField = field;
+                    acc[field] = fieldMapping[typedField] || field;
+                } else {
+                    acc[field] = field;
+                }
+                return acc;
+            }, {})
+        };
+        map[typedKey] = value;
+    });
+    // always add the role field to the user collection if not already present
+    if (!map[baModelKey.user].fields.role) {
+        map[baModelKey.user].fields.role = baModelFieldKeysToFieldNames.user.role;
+    }
+    return map;
+}
+/**
+ * Builds a collection schema map by analyzing collection overrides and extracting
+ * BetterAuth model keys and field mappings
+ *
+ * @param collectionOverrides - Collection override functions provided in plugin options
+ * @returns A collection schema map with default values merged with any overrides
+ */ export function buildCollectionSchemaMap(pluginOptions) {
+    const collectionOverrides = {
+        users: pluginOptions.users?.collectionOverrides,
+        accounts: pluginOptions.accounts?.collectionOverrides,
+        sessions: pluginOptions.sessions?.collectionOverrides,
+        verifications: pluginOptions.verifications?.collectionOverrides,
+        ...pluginOptions.pluginCollectionOverrides
+    };
+    const defaultCollectionSchemaMap = getDefaultCollectionSchemaMap(pluginOptions);
+    if (!collectionOverrides || Object.keys(collectionOverrides).length === 0) {
+        return {
+            ...defaultCollectionSchemaMap
+        };
+    }
+    const schemaMap = {
+        ...defaultCollectionSchemaMap
+    };
+    Object.entries(collectionOverrides).forEach(([collectionSlug, overrideFunction])=>{
+        if (!overrideFunction) return;
+        const modifiedCollection = overrideFunction({
+            collection: {
+                slug: collectionSlug,
+                fields: []
+            }
+        });
+        const modelKey = assertModelKey(modifiedCollection);
+        schemaMap[modelKey].collectionSlug = modifiedCollection.slug;
+        const flattenedFields = flattenAllFields(modifiedCollection);
+        if (flattenedFields && Array.isArray(flattenedFields)) {
+            flattenedFields.forEach((field)=>{
+                // we only want to process fields that have a betterAuthFieldKey
+                // because its possible the user has added additional fields
+                if (field.custom?.betterAuthFieldKey) {
+                    const fieldKey = assertFieldKey(field, modelKey, modifiedCollection.slug);
+                    schemaMap[modelKey].fields[fieldKey] = field.name;
+                }
+            });
+        }
+    });
+    return schemaMap;
+}
+function assertFieldKey(field, modelKey, collectionSlug) {
+    const fieldKey = field.custom?.betterAuthFieldKey;
+    // Assert that fieldKey is a valid key in the baModelFieldKeysToFieldNames mapping
+    if (!Object.values(baModelFieldKeysToFieldNames).some((fieldMap)=>Object.keys(fieldMap).includes(fieldKey))) {
+        throw new Error(`Invalid custom.betterAuthFieldKey: ${fieldKey} for field ${field.name} in collection ${collectionSlug}, 
+        must be one of ${Object.keys(baModelFieldKeysToFieldNames[modelKey]).join(', ')}`);
+    }
+    return fieldKey;
+}
+/**
+ * Asserts that a collection has a valid BetterAuth model key and returns it
+ *
+ * @param collection - The collection to check for a BetterAuth model key
+ * @returns The BetterAuth model key
+ * @throws Error if the collection does not have a valid BetterAuth model key
+ */ function assertModelKey(collection) {
+    if (!collection.custom?.betterAuthModelKey) {
+        throw new Error(`Collection ${collection.slug} is missing a betterAuthModelKey in its custom field`);
+    }
+    const modelKey = collection.custom.betterAuthModelKey;
+    if (!Object.values(baModelKey).includes(modelKey)) {
+        throw new Error(`Collection ${collection.slug} has an invalid betterAuthModelKey: ${modelKey}`);
+    }
+    return modelKey;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-collection-schema-map.ts"],"sourcesContent":["import { baModelFieldKeysToFieldNames, baModelKey } from '../constants'\nimport { getAuthTables } from 'better-auth/db'\nimport { BetterAuthOptions } from 'better-auth/types'\nimport { baModelKeyToSlug } from '../constants'\nimport { FlattenedField } from 'payload'\nimport { flattenAllFields } from 'payload/shared'\nimport { CollectionConfig } from 'payload'\nimport { getDeafultCollectionSlug } from './get-collection-slug'\nimport { BetterAuthPluginOptions } from '../types'\n\nexport type CollectionSchemaMap = Record<\n  keyof typeof baModelKey,\n  {\n    collectionSlug: string\n    fields: Record<string, string>\n  }\n>\n\nexport function getDefaultCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap {\n  const tables = getAuthTables(pluginOptions.betterAuthOptions ?? {})\n  const map = {} as CollectionSchemaMap\n  Object.entries(tables).forEach(([key, table]) => {\n    const fieldNames = Object.entries(table.fields).map(([k, v]) => k)\n    const typedKey = key as keyof typeof baModelKeyToSlug\n    const value = {\n      collectionSlug: getDeafultCollectionSlug({ modelKey: typedKey, pluginOptions }),\n      fields: fieldNames.reduce(\n        (acc, field) => {\n          if (\n            typedKey in baModelFieldKeysToFieldNames &&\n            field in baModelFieldKeysToFieldNames[typedKey as keyof typeof baModelFieldKeysToFieldNames]\n          ) {\n            const fieldMapping = baModelFieldKeysToFieldNames[typedKey as keyof typeof baModelFieldKeysToFieldNames]\n            const typedField = field as keyof typeof fieldMapping\n            acc[field] = fieldMapping[typedField] || field\n          } else {\n            acc[field] = field\n          }\n          return acc\n        },\n        {} as Record<string, string>\n      )\n    }\n\n    map[typedKey] = value\n  })\n\n  // always add the role field to the user collection if not already present\n  if (!map[baModelKey.user].fields.role) {\n    map[baModelKey.user].fields.role = baModelFieldKeysToFieldNames.user.role\n  }\n\n  return map\n}\n\ntype CollectionOverride = ((options: { collection: CollectionConfig }) => CollectionConfig) | undefined\n\ntype CollectionOverrides = Record<string, CollectionOverride>\n\n/**\n * Builds a collection schema map by analyzing collection overrides and extracting\n * BetterAuth model keys and field mappings\n *\n * @param collectionOverrides - Collection override functions provided in plugin options\n * @returns A collection schema map with default values merged with any overrides\n */\nexport function buildCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap {\n  const collectionOverrides = {\n    users: pluginOptions.users?.collectionOverrides,\n    accounts: pluginOptions.accounts?.collectionOverrides,\n    sessions: pluginOptions.sessions?.collectionOverrides,\n    verifications: pluginOptions.verifications?.collectionOverrides,\n    ...pluginOptions.pluginCollectionOverrides\n  }\n\n  const defaultCollectionSchemaMap = getDefaultCollectionSchemaMap(pluginOptions)\n\n  if (!collectionOverrides || Object.keys(collectionOverrides).length === 0) {\n    return { ...defaultCollectionSchemaMap }\n  }\n\n  const schemaMap = { ...defaultCollectionSchemaMap }\n\n  Object.entries(collectionOverrides).forEach(([collectionSlug, overrideFunction]) => {\n    if (!overrideFunction) return\n\n    const modifiedCollection = overrideFunction({\n      collection: {\n        slug: collectionSlug,\n        fields: []\n      }\n    })\n    const modelKey = assertModelKey(modifiedCollection)\n    schemaMap[modelKey].collectionSlug = modifiedCollection.slug\n    const flattenedFields = flattenAllFields(modifiedCollection)\n    if (flattenedFields && Array.isArray(flattenedFields)) {\n      flattenedFields.forEach((field: FlattenedField) => {\n        // we only want to process fields that have a betterAuthFieldKey\n        // because its possible the user has added additional fields\n        if (field.custom?.betterAuthFieldKey) {\n          const fieldKey = assertFieldKey(field, modelKey, modifiedCollection.slug)\n          schemaMap[modelKey].fields[fieldKey] = field.name\n        }\n      })\n    }\n  })\n\n  return schemaMap\n}\n\nfunction assertFieldKey(field: FlattenedField, modelKey: keyof typeof baModelKey, collectionSlug: string) {\n  const fieldKey = field.custom?.betterAuthFieldKey as string\n\n  // Assert that fieldKey is a valid key in the baModelFieldKeysToFieldNames mapping\n  if (!Object.values(baModelFieldKeysToFieldNames).some((fieldMap) => Object.keys(fieldMap).includes(fieldKey))) {\n    throw new Error(\n      `Invalid custom.betterAuthFieldKey: ${fieldKey} for field ${field.name} in collection ${collectionSlug}, \n        must be one of ${Object.keys(baModelFieldKeysToFieldNames[modelKey as keyof typeof baModelFieldKeysToFieldNames]).join(', ')}`\n    )\n  }\n\n  return fieldKey\n}\n\n/**\n * Asserts that a collection has a valid BetterAuth model key and returns it\n *\n * @param collection - The collection to check for a BetterAuth model key\n * @returns The BetterAuth model key\n * @throws Error if the collection does not have a valid BetterAuth model key\n */\nfunction assertModelKey(collection: CollectionConfig): keyof typeof baModelKey {\n  if (!collection.custom?.betterAuthModelKey) {\n    throw new Error(`Collection ${collection.slug} is missing a betterAuthModelKey in its custom field`)\n  }\n\n  const modelKey = collection.custom.betterAuthModelKey as keyof typeof baModelKey\n\n  if (!Object.values(baModelKey).includes(modelKey as any)) {\n    throw new Error(`Collection ${collection.slug} has an invalid betterAuthModelKey: ${modelKey}`)\n  }\n\n  return modelKey\n}\n"],"names":["baModelFieldKeysToFieldNames","baModelKey","getAuthTables","flattenAllFields","getDeafultCollectionSlug","getDefaultCollectionSchemaMap","pluginOptions","tables","betterAuthOptions","map","Object","entries","forEach","key","table","fieldNames","fields","k","v","typedKey","value","collectionSlug","modelKey","reduce","acc","field","fieldMapping","typedField","user","role","buildCollectionSchemaMap","collectionOverrides","users","accounts","sessions","verifications","pluginCollectionOverrides","defaultCollectionSchemaMap","keys","length","schemaMap","overrideFunction","modifiedCollection","collection","slug","assertModelKey","flattenedFields","Array","isArray","custom","betterAuthFieldKey","fieldKey","assertFieldKey","name","values","some","fieldMap","includes","Error","join","betterAuthModelKey"],"mappings":"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"}

package/dist/better-auth/plugin/helpers/get-collection-slug.d.ts

@@ -0,0 +1,6 @@
+import type { BetterAuthPluginOptions } from '../types';
+export declare function getDeafultCollectionSlug({ pluginOptions, modelKey }: {
+    pluginOptions: BetterAuthPluginOptions;
+    modelKey: string;
+}): string;
+//# sourceMappingURL=get-collection-slug.d.ts.map

package/dist/better-auth/plugin/helpers/get-collection-slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-collection-slug.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection-slug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAGvD,wBAAgB,wBAAwB,CAAC,EACvC,aAAa,EACb,QAAQ,EACT,EAAE;IACD,aAAa,EAAE,uBAAuB,CAAA;IACtC,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,MAAM,CAiBT"}

package/dist/better-auth/plugin/helpers/get-collection-slug.js

@@ -0,0 +1,20 @@
+import { baseSlugs, baModelKeyToSlug } from "../constants";
+export function getDeafultCollectionSlug({ pluginOptions, modelKey }) {
+    const baseSlug = baModelKeyToSlug[modelKey] ?? modelKey;
+    switch(modelKey){
+        case 'user':
+            return pluginOptions.users?.slug ?? baseSlugs.users;
+        case 'account':
+            return pluginOptions.accounts?.slug ?? baseSlugs.accounts;
+        case 'session':
+            return pluginOptions.sessions?.slug ?? baseSlugs.sessions;
+        case 'verification':
+            return pluginOptions.verifications?.slug ?? baseSlugs.verifications;
+        case 'adminInvitation':
+            return pluginOptions.adminInvitations?.slug ?? baseSlugs.adminInvitations;
+        default:
+            return baseSlug;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/get-collection.d.ts

@@ -0,0 +1,41 @@
+import type { Collection, CollectionConfig, Field } from 'payload';
+/**
+ * Retrieves a collection from the collection map based on its Better Auth model key
+ *
+ * This function searches through the provided collection map to find a collection
+ * that has been marked with a specific Better Auth model key in its custom properties.
+ * It's used to map between Better Auth's internal model keys and Payload CMS collections.
+ *
+ * @param collectionMap - Map of all available collections
+ * @param betterAuthModelKey - The Better Auth model key to search for
+ * @returns The matched collection configuration
+ * @throws {Error} If no collection with the specified Better Auth model key is found
+ */
+export declare function getMappedCollection({ collectionMap, betterAuthModelKey }: {
+    collectionMap: Record<string, CollectionConfig>;
+    betterAuthModelKey: string;
+}): CollectionConfig;
+interface MappedField extends Omit<Field, 'type'> {
+    name: string;
+    type: Exclude<Field['type'], 'tabs' | 'row' | 'collapsible'>;
+}
+/**
+ * Retrieves a field from a collection based on its Better Auth field key
+ *
+ * This function searches through the fields of a provided collection to find a field
+ * that has been marked with a specific Better Auth field key in its custom properties.
+ * It's used to map between Better Auth's internal field keys and Payload CMS field configurations.
+ *
+ * @param collection - The collection configuration to search within
+ * @param betterAuthFieldKey - The Better Auth field key to search for
+ * @returns The matched field configuration with a guaranteed name and non-UI type
+ * @throws {Error} If no field with the specified Better Auth field key is found
+ * @throws {Error} If the found field is a UI-only field type (tabs, row, collapsible)
+ */
+export declare function getMappedField({ collection, betterAuthFieldKey }: {
+    collection: CollectionConfig;
+    betterAuthFieldKey: string;
+}): MappedField;
+export declare function transformCollectionsToCollectionConfigs(collections: Record<string, Collection>): Record<string, CollectionConfig>;
+export {};
+//# sourceMappingURL=get-collection.d.ts.map

package/dist/better-auth/plugin/helpers/get-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-collection.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAElE;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,aAAa,EACb,kBAAkB,EACnB,EAAE;IACD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAC/C,kBAAkB,EAAE,MAAM,CAAA;CAC3B,GAAG,gBAAgB,CAcnB;AAED,UAAU,WAAY,SAAQ,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;CAC7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,UAAU,EACV,kBAAkB,EACnB,EAAE;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,kBAAkB,EAAE,MAAM,CAAA;CAC3B,GAAG,WAAW,CAmBd;AAED,wBAAgB,uCAAuC,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAIjI"}

package/dist/better-auth/plugin/helpers/get-collection.js

@@ -0,0 +1,62 @@
+/**
+ * Retrieves a collection from the collection map based on its Better Auth model key
+ *
+ * This function searches through the provided collection map to find a collection
+ * that has been marked with a specific Better Auth model key in its custom properties.
+ * It's used to map between Better Auth's internal model keys and Payload CMS collections.
+ *
+ * @param collectionMap - Map of all available collections
+ * @param betterAuthModelKey - The Better Auth model key to search for
+ * @returns The matched collection configuration
+ * @throws {Error} If no collection with the specified Better Auth model key is found
+ */ export function getMappedCollection({ collectionMap, betterAuthModelKey }) {
+    // Find the collection that has the matching betterAuthModelKey in its custom properties
+    const collection = Object.values(collectionMap).find((c)=>{
+        return c.custom?.betterAuthModelKey === betterAuthModelKey;
+    });
+    // Throw an error if no matching collection is found
+    if (!collection) {
+        const error = new Error(`Collection with key ${betterAuthModelKey} not found`);
+        Error.captureStackTrace(error, getMappedCollection);
+        throw error;
+    }
+    return collection;
+}
+/**
+ * Retrieves a field from a collection based on its Better Auth field key
+ *
+ * This function searches through the fields of a provided collection to find a field
+ * that has been marked with a specific Better Auth field key in its custom properties.
+ * It's used to map between Better Auth's internal field keys and Payload CMS field configurations.
+ *
+ * @param collection - The collection configuration to search within
+ * @param betterAuthFieldKey - The Better Auth field key to search for
+ * @returns The matched field configuration with a guaranteed name and non-UI type
+ * @throws {Error} If no field with the specified Better Auth field key is found
+ * @throws {Error} If the found field is a UI-only field type (tabs, row, collapsible)
+ */ export function getMappedField({ collection, betterAuthFieldKey }) {
+    // Find the field that has the matching betterAuthFieldKey in its custom properties
+    const field = collection.fields.find((f)=>f.custom?.betterAuthFieldKey === betterAuthFieldKey);
+    // Throw an error if no matching field is found
+    if (!field) {
+        throw new Error(`Field with key ${betterAuthFieldKey} not found`);
+    }
+    // Filter out UI-based fields that don't have a name or aren't data fields
+    // These field types are used for layout purposes only and cannot store data
+    switch(field.type){
+        case 'tabs':
+        case 'row':
+        case 'collapsible':
+            throw new Error(`Field with key ${betterAuthFieldKey} is a UI-only field and cannot be used for data`);
+        default:
+            return field;
+    }
+}
+export function transformCollectionsToCollectionConfigs(collections) {
+    return Object.fromEntries(Object.entries(collections).map(([slug, collection])=>[
+            slug,
+            collection.config
+        ]));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/prepare-session-data.d.ts

@@ -1,22 +1,60 @@
-import type { Config, Payload } from 'payload';
-type CollectionSlugs = {
-    userCollectionSlug: string;
-    sessionCollectionSlug: string;
-};
+import { Session, User } from 'better-auth';
+import type { CollectionConfig } from 'payload';
+export declare function prepareUser({ user, userCollection }: {
+    user: User & Record<string, any>;
+    userCollection: CollectionConfig;
+}): Promise<{
+    id: string;
+    name: string;
+    email: string;
+    emailVerified: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    image?: string | null | undefined;
+} & Record<string, any>>;
+export declare function prepareSession({ session, sessionCollection }: {
+    session: Session & Record<string, any>;
+    sessionCollection: CollectionConfig;
+}): Promise<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+} & Record<string, any>>;
 /**
  * Prepares session data for cookie cache by filtering user and session objects
  * based on the payload configuration's 'saveToJwt' property
  */
-export declare function prepareSessionData({ newSession, payloadConfig, collectionSlugs }: {
-    newSession: {
-        user: any;
-        session: any;
+export declare function prepareSessionData({ sessionData, usersCollection, sessionsCollection }: {
+    sessionData: {
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
     };
-    payloadConfig: Payload['config'] | Config | Promise<Payload['config'] | Config>;
-    collectionSlugs: CollectionSlugs;
+    usersCollection: CollectionConfig;
+    sessionsCollection: CollectionConfig;
 }): Promise<{
-    user: Record<string, unknown>;
-    session: any;
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    } & Record<string, any>;
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        emailVerified: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        image?: string | null | undefined;
+    } & Record<string, any>;
 } | null>;
-export {};
 //# sourceMappingURL=prepare-session-data.d.ts.map

package/dist/better-auth/plugin/helpers/prepare-session-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare-session-data.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAE9C,KAAK,eAAe,GAAG;IACrB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,qBAAqB,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,UAAU,EACV,aAAa,EACb,eAAe,EAChB,EAAE;IACD,UAAU,EAAE;QACV,IAAI,EAAE,GAAG,CAAA;QACT,OAAO,EAAE,GAAG,CAAA;KACb,CAAA;IACD,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAA;IAC/E,eAAe,EAAE,eAAe,CAAA;CACjC;;;UA6CA"}
+{"version":3,"file":"prepare-session-data.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAc,gBAAgB,EAAmB,MAAM,SAAS,CAAA;AAK5E,wBAAsB,WAAW,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE;IAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,cAAc,EAAE,gBAAgB,CAAA;CAAE;;;;;;;;yBAWjI;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,iBAAiB,EAClB,EAAE;IACD,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACtC,iBAAiB,EAAE,gBAAgB,CAAA;CACpC;;;;;;;;;yBAiBA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,WAAW,EACX,eAAe,EACf,kBAAkB,EACnB,EAAE;IACD,WAAW,EAAE;QACX,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACtC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KACjC,CAAA;IACD,eAAe,EAAE,gBAAgB,CAAA;IACjC,kBAAkB,EAAE,gBAAgB,CAAA;CACrC;;;;;;;;;;;;;;;;;;;;UAYA"}

package/dist/better-auth/plugin/helpers/prepare-session-data.js

@@ -1,43 +1,49 @@
 import { getFieldsToSign } from "payload";
+export async function prepareUser({ user, userCollection }) {
+    const newUser = getFieldsToSign({
+        collectionConfig: userCollection,
+        email: user.email,
+        user: {
+            ...user,
+            collection: userCollection.slug
+        }
+    });
+    return newUser;
+}
+export async function prepareSession({ session, sessionCollection }) {
+    const filteredSession = getFieldsToSign({
+        collectionConfig: sessionCollection,
+        email: '',
+        user: {
+            ...session,
+            collection: sessionCollection.slug
+        }
+    });
+    delete filteredSession.email;
+    delete filteredSession.collection;
+    Object.assign(filteredSession, {
+        userId: session.userId
+    });
+    return filteredSession;
+}
 /**
  * Prepares session data for cookie cache by filtering user and session objects
  * based on the payload configuration's 'saveToJwt' property
- */ export async function prepareSessionData({ newSession, payloadConfig, collectionSlugs }) {
-    if (!newSession || !newSession.user) {
-        return null;
-    }
-    const awaitedPayloadConfig = await payloadConfig;
-    const { userCollectionSlug, sessionCollectionSlug } = collectionSlugs;
-    const userCollection = awaitedPayloadConfig?.collections?.find((c)=>c.slug === userCollectionSlug);
-    const sessionCollection = awaitedPayloadConfig?.collections?.find((c)=>c.slug === sessionCollectionSlug);
-    if (!userCollection) {
-        throw new Error(`User collection with slug '${userCollectionSlug}' not found`);
-    }
-    const filteredUser = getFieldsToSign({
-        collectionConfig: userCollection,
-        email: newSession.user.email,
-        user: newSession.user
+ */ export async function prepareSessionData({ sessionData, usersCollection, sessionsCollection }) {
+    if (!sessionData || !sessionData.user) return null;
+    const newUser = await prepareUser({
+        user: sessionData.user,
+        userCollection: usersCollection
+    });
+    const newSession = await prepareSession({
+        session: sessionData.session,
+        sessionCollection: sessionsCollection
     });
-    let filteredSession = newSession.session;
-    const isImpersonated = newSession.session.impersonatedBy;
-    if (sessionCollection && newSession.session) {
-        filteredSession = getFieldsToSign({
-            collectionConfig: sessionCollection,
-            email: newSession.user.email,
-            user: newSession.session
-        });
-        // getFieldsToSign is meant for auth collections so we remove the email and collection fields
-        delete filteredSession.email;
-        delete filteredSession.collection;
-    }
-    if (isImpersonated) {
-        filteredSession.impersonatedBy = newSession.session.impersonatedBy;
-    }
-    return {
-        ...newSession,
-        user: filteredUser,
-        session: filteredSession
+    const newSessionData = {
+        session: newSession,
+        user: newUser
     };
+    return newSessionData;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/index.d.ts

@@ -1,8 +1,8 @@
-import type { Config } from 'payload';
+import { type Config } from 'payload';
 import type { BetterAuthPluginOptions } from './types';
-export { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index';
+export * from './helpers/index';
 export { getPayloadAuth } from './lib/get-payload-auth';
+export { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index';
 export * from './types';
-export * from './helpers/index';
 export declare function betterAuthPlugin(pluginOptions: BetterAuthPluginOptions): (config: Config) => Config;
 //# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAStD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAA;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,cAAc,SAAS,CAAA;AACvB,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,IAC7D,QAAQ,MAAM,KAAG,MAAM,CAqJhC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2D,KAAK,MAAM,EAAc,MAAM,SAAS,CAAA;AAQ1G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAItD,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAA;AACpF,cAAc,SAAS,CAAA;AAEvB,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,IAC7D,QAAQ,MAAM,KAAG,MAAM,CA2IhC"}