@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

package/dist/better-auth/core/common.d.ts

@@ -0,0 +1,6 @@
+export type { PluginModule } from '@baseplate-dev/project-builder-lib';
+declare const _default: import("@baseplate-dev/project-builder-lib").PluginModule<{
+    [x: string]: import("@baseplate-dev/project-builder-lib").PluginSpec<object, object>;
+}>;
+export default _default;
+//# sourceMappingURL=common.d.ts.map

package/dist/better-auth/core/common.js

@@ -0,0 +1,20 @@
+import { authModelsSpec, createPluginModule, definitionIssueCheckerSpec, pluginConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { BETTER_AUTH_MODELS } from '../constants/model-names.js';
+import { createBetterAuthPluginDefinitionSchema } from './schema/plugin-definition.js';
+import { createBetterAuthSchemaChecker } from './schema/schema-issue-checker.js';
+export default createPluginModule({
+    name: 'common',
+    dependencies: {
+        pluginConfig: pluginConfigSpec,
+        authModels: authModelsSpec,
+        issueCheckers: definitionIssueCheckerSpec,
+    },
+    initialize: ({ pluginConfig, authModels, issueCheckers }, { pluginKey }) => {
+        pluginConfig.schemas.set(pluginKey, createBetterAuthPluginDefinitionSchema);
+        authModels.getAuthModels.set(() => ({
+            user: BETTER_AUTH_MODELS.user,
+        }));
+        issueCheckers.checkers.set(pluginKey, createBetterAuthSchemaChecker(pluginKey));
+    },
+});
+//# sourceMappingURL=common.js.map

package/dist/better-auth/core/components/better-auth-definition-editor.d.ts

@@ -0,0 +1,5 @@
+import type { WebConfigProps } from '@baseplate-dev/project-builder-lib';
+import type React from 'react';
+import '#src/styles.css';
+export declare function BetterAuthDefinitionEditor({ definition: pluginMetadata, metadata, onSave, }: WebConfigProps): React.JSX.Element;
+//# sourceMappingURL=better-auth-definition-editor.d.ts.map

package/dist/better-auth/core/components/better-auth-definition-editor.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { applyMergedDefinition, diffDefinition, PluginUtils, } from '@baseplate-dev/project-builder-lib';
+import { DefinitionDiffAlert, useBlockUnsavedChangesNavigate, useDefinitionSchema, useProjectDefinition, useResettableForm, } from '@baseplate-dev/project-builder-lib/web';
+import { FormActionBar, MultiComboboxFieldController, SectionList, SectionListSection, SectionListSectionContent, SectionListSectionDescription, SectionListSectionHeader, SectionListSectionTitle, } from '@baseplate-dev/ui-components';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useMemo } from 'react';
+import { getAuthPluginDefinition } from '#src/auth/utils/get-auth-plugin-definition.js';
+import { AuthConfigTabs } from '#src/common/components/auth-config-tabs.js';
+import { createBetterAuthPartialDefinition } from '../schema/models.js';
+import { createBetterAuthPluginDefinitionSchema } from '../schema/plugin-definition.js';
+import '#src/styles.css';
+export function BetterAuthDefinitionEditor({ definition: pluginMetadata, metadata, onSave, }) {
+    const { definition, definitionContainer, saveDefinitionWithFeedback } = useProjectDefinition();
+    const betterAuthPluginDefinitionSchema = useDefinitionSchema(createBetterAuthPluginDefinitionSchema);
+    const authDefinition = getAuthPluginDefinition(definition);
+    const roles = authDefinition.roles
+        .filter((role) => !role.builtIn)
+        .map((role) => ({
+        label: role.name,
+        value: role.id,
+    }));
+    const defaultValues = useMemo(() => {
+        if (pluginMetadata?.config) {
+            return pluginMetadata.config;
+        }
+        return {
+            additionalUserAdminRoles: [],
+        };
+    }, [pluginMetadata?.config]);
+    const form = useResettableForm({
+        resolver: zodResolver(betterAuthPluginDefinitionSchema),
+        defaultValues,
+    });
+    const { control, reset, handleSubmit } = form;
+    const authFeature = definition.features.find((f) => f.id === authDefinition.authFeatureRef);
+    if (!authFeature) {
+        throw new Error(`Auth feature not found for ref: ${authDefinition.authFeatureRef}`);
+    }
+    const accountsFeature = definition.features.find((f) => f.id === authDefinition.accountsFeatureRef);
+    if (!accountsFeature) {
+        throw new Error(`Accounts feature not found for ref: ${authDefinition.accountsFeatureRef}`);
+    }
+    const partialDef = useMemo(() => createBetterAuthPartialDefinition(authFeature.name, accountsFeature.name), [authFeature.name, accountsFeature.name]);
+    const diff = useMemo(() => diffDefinition(definitionContainer.schema, definitionContainer.definition, partialDef), [definitionContainer, partialDef]);
+    const onSubmit = handleSubmit((data) => saveDefinitionWithFeedback((draftConfig) => {
+        const updatedData = {
+            ...data,
+        };
+        applyMergedDefinition(definitionContainer, partialDef)(draftConfig);
+        PluginUtils.setPluginConfig(draftConfig, metadata, updatedData, definitionContainer);
+    }, {
+        successMessage: 'Successfully saved Better Auth plugin!',
+        onSuccess: () => {
+            onSave();
+        },
+    }));
+    useBlockUnsavedChangesNavigate({ control, reset, onSubmit });
+    return (_jsxs("div", { className: "auth:relative auth:flex auth:h-full auth:flex-1 auth:flex-col auth:gap-4 auth:overflow-hidden", children: [_jsx(AuthConfigTabs, {}), _jsx("div", { className: "auth:mb-[--action-bar-height] auth:flex auth:flex-1 auth:overflow-y-auto", style: {
+                    '--action-bar-height': '52px',
+                }, children: _jsxs("form", { onSubmit: onSubmit, className: "auth:max-w-6xl auth:flex-1", children: [_jsx("div", { className: "auth:pb-16", children: _jsxs(SectionList, { children: [_jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "Better Auth Configuration" }), _jsx(SectionListSectionDescription, { children: "The plugin will automatically configure the models it needs." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(DefinitionDiffAlert, { diff: diff, upToDateMessage: "All required models are already configured correctly. No changes needed." }) })] }), _jsxs(SectionListSection, { children: [_jsxs(SectionListSectionHeader, { children: [_jsx(SectionListSectionTitle, { children: "User Management Permissions" }), _jsx(SectionListSectionDescription, { children: "The \"admin\" role always has user management permissions. Optionally add more roles that can manage users and assign roles in the admin interface." })] }), _jsx(SectionListSectionContent, { className: "auth:space-y-6", children: _jsx(MultiComboboxFieldController, { label: "Additional User Admin Roles", name: "additionalUserAdminRoles", control: control, options: roles, description: "Additional roles (beyond admin) that can manage users and assign roles." }) })] })] }) }), _jsx(FormActionBar, { form: form, allowSaveWithoutDirty: !pluginMetadata || diff.hasChanges })] }) })] }));
+}
+//# sourceMappingURL=better-auth-definition-editor.js.map

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

@@ -0,0 +1,2 @@
+export type * from './schema/plugin-definition.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/core/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/better-auth/core/node.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("@baseplate-dev/project-builder-lib").PluginModule<{
+    [x: string]: import("@baseplate-dev/project-builder-lib").PluginSpec<object, object>;
+}>;
+export default _default;
+//# sourceMappingURL=node.d.ts.map

package/dist/better-auth/core/node.js

@@ -0,0 +1,64 @@
+import { emailTemplateSpec } from '@baseplate-dev/plugin-email';
+import { appCompilerSpec, backendAppEntryType, createPluginModule, pluginAppCompiler, PluginUtils, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
+import { reactRoutesGenerator } from '@baseplate-dev/react-generators';
+import { getAuthPluginDefinition } from '#src/auth/utils/get-auth-plugin-definition.js';
+import { betterAuthAdminModuleGenerator, betterAuthEmailTemplatesGenerator, betterAuthHooksGenerator, betterAuthModuleGenerator, betterAuthPagesGenerator, betterAuthSeedInitialUserGenerator, reactBetterAuthGenerator, } from '../generators/index.js';
+export default createPluginModule({
+    name: 'node',
+    dependencies: {
+        appCompiler: appCompilerSpec,
+        emailTemplate: emailTemplateSpec,
+    },
+    initialize: ({ appCompiler, emailTemplate }, { pluginKey }) => {
+        // Register auth email templates with the transactional lib
+        emailTemplate.generators.push(betterAuthEmailTemplatesGenerator({}));
+        appCompiler.compilers.push(pluginAppCompiler({
+            pluginKey,
+            appType: backendAppEntryType,
+            compile: ({ projectDefinition, appDefinition, appCompiler, definitionContainer, }) => {
+                const auth = getAuthPluginDefinition(projectDefinition);
+                const betterAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
+                // Get web app ports
+                const webApps = projectDefinition.apps.filter((app) => app.type === 'web');
+                const devWebPorts = webApps.map((app) => app.devPort);
+                const devWebDomainPort = devWebPorts[0] ??
+                    projectDefinition.settings.general.portOffset + 30;
+                const additionalAdminRoles = betterAuthDefinition.additionalUserAdminRoles.map((role) => definitionContainer.nameFromId(role));
+                // 'admin' is always included since it is now a built-in role guaranteed to exist
+                const adminRoles = [...new Set(['admin', ...additionalAdminRoles])];
+                appCompiler.addChildrenToFeature(auth.authFeatureRef, {
+                    seedInitialUser: betterAuthSeedInitialUserGenerator({
+                        initialUserRoles: ['admin'],
+                    }),
+                    betterAuthModule: betterAuthModuleGenerator({
+                        devWebPorts,
+                        devBackendPort: appDefinition.devPort,
+                        devWebDomainPort,
+                    }),
+                    betterAuthAdminModule: betterAuthAdminModuleGenerator({
+                        adminRoles,
+                    }),
+                });
+            },
+        }), pluginAppCompiler({
+            pluginKey,
+            appType: webAppEntryType,
+            compile: ({ appCompiler, projectDefinition }) => {
+                const auth = getAuthPluginDefinition(projectDefinition);
+                appCompiler.addRootChildren({
+                    auth: reactBetterAuthGenerator({}),
+                    authHooks: betterAuthHooksGenerator({
+                        authRoles: auth.roles.map((role) => role.name),
+                    }),
+                    betterAuthPages: reactRoutesGenerator({
+                        name: 'auth',
+                        children: {
+                            auth: betterAuthPagesGenerator({}),
+                        },
+                    }),
+                });
+            },
+        }));
+    },
+});
+//# sourceMappingURL=node.js.map

package/dist/better-auth/core/schema/models.d.ts

@@ -0,0 +1,3 @@
+import type { PartialProjectDefinitionInput } from '@baseplate-dev/project-builder-lib';
+export declare function createBetterAuthPartialDefinition(authFeatureName: string, accountsFeatureName: string): PartialProjectDefinitionInput;
+//# sourceMappingURL=models.d.ts.map

package/dist/better-auth/core/schema/models.js

@@ -0,0 +1,293 @@
+import { BETTER_AUTH_MODELS } from '#src/better-auth/constants/model-names.js';
+export function createBetterAuthPartialDefinition(authFeatureName, accountsFeatureName) {
+    return {
+        models: [
+            {
+                name: BETTER_AUTH_MODELS.user,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'name',
+                            type: 'string',
+                            isOptional: false,
+                        },
+                        {
+                            name: 'email',
+                            type: 'string',
+                            isOptional: false,
+                        },
+                        {
+                            name: 'emailVerified',
+                            type: 'boolean',
+                            options: { default: 'false' },
+                        },
+                        {
+                            name: 'image',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'email' }],
+                        },
+                    ],
+                },
+                graphql: {
+                    objectType: {
+                        enabled: true,
+                        fields: [
+                            { ref: 'id' },
+                            {
+                                ref: 'email',
+                                globalRoles: ['admin'],
+                                instanceRoles: ['self'],
+                            },
+                        ],
+                    },
+                },
+                authorizer: {
+                    roles: [
+                        {
+                            name: 'self',
+                            expression: 'model.id === userId',
+                        },
+                    ],
+                },
+            },
+            {
+                name: BETTER_AUTH_MODELS.session,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'expiresAt',
+                            type: 'dateTime',
+                        },
+                        {
+                            name: 'token',
+                            type: 'string',
+                        },
+                        {
+                            name: 'ipAddress',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'userAgent',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    uniqueConstraints: [
+                        {
+                            fields: [{ fieldRef: 'token' }],
+                        },
+                    ],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: BETTER_AUTH_MODELS.user,
+                            foreignRelationName: 'sessions',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+            {
+                name: BETTER_AUTH_MODELS.account,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv7' },
+                        },
+                        {
+                            name: 'accountId',
+                            type: 'string',
+                        },
+                        {
+                            name: 'providerId',
+                            type: 'string',
+                        },
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'accessToken',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'refreshToken',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'idToken',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'accessTokenExpiresAt',
+                            type: 'dateTime',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'refreshTokenExpiresAt',
+                            type: 'dateTime',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'scope',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'password',
+                            type: 'string',
+                            isOptional: true,
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: BETTER_AUTH_MODELS.user,
+                            foreignRelationName: 'accounts',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+            {
+                name: BETTER_AUTH_MODELS.verification,
+                featureRef: authFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'id',
+                            type: 'uuid',
+                            options: { defaultGeneration: 'uuidv4' },
+                        },
+                        {
+                            name: 'identifier',
+                            type: 'string',
+                        },
+                        {
+                            name: 'value',
+                            type: 'string',
+                        },
+                        {
+                            name: 'expiresAt',
+                            type: 'dateTime',
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['id'],
+                },
+            },
+            {
+                name: BETTER_AUTH_MODELS.userRole,
+                featureRef: accountsFeatureName,
+                model: {
+                    fields: [
+                        {
+                            name: 'userId',
+                            type: 'uuid',
+                        },
+                        {
+                            name: 'role',
+                            type: 'string',
+                        },
+                        {
+                            name: 'updatedAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true, updatedAt: true },
+                        },
+                        {
+                            name: 'createdAt',
+                            type: 'dateTime',
+                            options: { defaultToNow: true },
+                        },
+                    ],
+                    primaryKeyFieldRefs: ['userId', 'role'],
+                    relations: [
+                        {
+                            name: 'user',
+                            references: [{ localRef: 'userId', foreignRef: 'id' }],
+                            modelRef: BETTER_AUTH_MODELS.user,
+                            foreignRelationName: 'roles',
+                            onDelete: 'Cascade',
+                            onUpdate: 'Restrict',
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=models.js.map

package/dist/better-auth/core/schema/plugin-definition.d.ts

@@ -0,0 +1,8 @@
+import type { def } from '@baseplate-dev/project-builder-lib';
+import { z } from 'zod';
+export declare const createBetterAuthPluginDefinitionSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{
+    additionalUserAdminRoles: z.ZodPrefault<z.ZodArray<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+}, z.core.$strip>;
+export type BetterAuthPluginDefinition = def.InferOutput<typeof createBetterAuthPluginDefinitionSchema>;
+export type BetterAuthPluginDefinitionInput = def.InferInput<typeof createBetterAuthPluginDefinitionSchema>;
+//# sourceMappingURL=plugin-definition.d.ts.map

package/dist/better-auth/core/schema/plugin-definition.js

@@ -0,0 +1,9 @@
+import { authRoleEntityType, definitionSchema, } from '@baseplate-dev/project-builder-lib';
+import { z } from 'zod';
+export const createBetterAuthPluginDefinitionSchema = definitionSchema((ctx) => z.object({
+    additionalUserAdminRoles: ctx.withDefault(z.array(ctx.withRef({
+        type: authRoleEntityType,
+        onDelete: 'DELETE',
+    })), []),
+}));
+//# sourceMappingURL=plugin-definition.js.map

package/dist/better-auth/core/schema/schema-issue-checker.d.ts

@@ -0,0 +1,3 @@
+import type { DefinitionIssueChecker } from '@baseplate-dev/project-builder-lib';
+export declare function createBetterAuthSchemaChecker(pluginKey: string): DefinitionIssueChecker;
+//# sourceMappingURL=schema-issue-checker.d.ts.map

package/dist/better-auth/core/schema/schema-issue-checker.js

@@ -0,0 +1,21 @@
+import { createPluginModelSyncChecker, FeatureUtils, } from '@baseplate-dev/project-builder-lib';
+import { getAuthPluginDefinition } from '#src/auth/index.js';
+import { createBetterAuthPartialDefinition } from './models.js';
+export function createBetterAuthSchemaChecker(pluginKey) {
+    return createPluginModelSyncChecker({
+        pluginKey,
+        pluginLabel: 'Better Auth',
+        buildPartialDef: (container) => {
+            const authConfig = getAuthPluginDefinition(container.definition);
+            try {
+                const authFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.authFeatureRef);
+                const accountsFeatureName = FeatureUtils.getFeaturePathByIdOrThrow(container.definition, authConfig.accountsFeatureRef);
+                return createBetterAuthPartialDefinition(authFeatureName, accountsFeatureName);
+            }
+            catch {
+                return undefined;
+            }
+        },
+    });
+}
+//# sourceMappingURL=schema-issue-checker.js.map

package/dist/better-auth/core/web.d.ts

@@ -0,0 +1,6 @@
+import '../../styles.css';
+declare const _default: import("@baseplate-dev/project-builder-lib").PluginModule<{
+    [x: string]: import("@baseplate-dev/project-builder-lib").PluginSpec<object, object>;
+}>;
+export default _default;
+//# sourceMappingURL=web.d.ts.map

package/dist/better-auth/core/web.js

@@ -0,0 +1,26 @@
+import { createPluginModule, FeatureUtils, pluginDefaultsSpec, webConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { BetterAuthDefinitionEditor } from './components/better-auth-definition-editor.js';
+import { createBetterAuthPartialDefinition } from './schema/models.js';
+import '../../styles.css';
+const AUTH_FEATURE_NAME = 'accounts/auth';
+const ACCOUNTS_FEATURE_NAME = 'accounts/users';
+export default createPluginModule({
+    name: 'web',
+    dependencies: {
+        webConfig: webConfigSpec,
+        pluginDefaults: pluginDefaultsSpec,
+    },
+    initialize: ({ webConfig, pluginDefaults }, { pluginKey }) => {
+        webConfig.components.set(pluginKey, BetterAuthDefinitionEditor);
+        pluginDefaults.builders.set(pluginKey, ({ draft }) => {
+            // Idempotent with the parent auth builder, which also ensures these.
+            FeatureUtils.ensureFeatureByNameRecursively(draft, AUTH_FEATURE_NAME);
+            FeatureUtils.ensureFeatureByNameRecursively(draft, ACCOUNTS_FEATURE_NAME);
+            return {
+                config: {},
+                partialDef: createBetterAuthPartialDefinition(AUTH_FEATURE_NAME, ACCOUNTS_FEATURE_NAME),
+            };
+        });
+    },
+});
+//# sourceMappingURL=web.js.map

package/dist/better-auth/generators/fastify/better-auth-admin-module/better-auth-admin-module.generator.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Generator for better-auth admin mutations.
+ *
+ * Adds GraphQL mutations for admin operations:
+ * - resetUserPassword: Allows admins to reset any user's password
+ * - updateUserRoles: Allows admins to manage user role assignments
+ */
+export declare const betterAuthAdminModuleGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    adminRoles: string[];
+}, {
+    paths: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthAdminModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators/src/index.js").AppModuleProvider>;
+    }, undefined>;
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthAdminModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            resetUserPassword: {};
+            updateUserRoles: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+    }, undefined>;
+    renderers: import("@baseplate-dev/sync").GeneratorTask<{
+        betterAuthBetterAuthAdminModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+    }, {
+        authRolesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AUTH_ROLE_CONFIG: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+            DEFAULT_PUBLIC_ROLES: {};
+            DEFAULT_USER_ROLES: {};
+            RoleConfig: {
+                isTypeOnly: true;
+            };
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            throwIfPrismaNotFound: {};
+            TooManyRequestsError: {};
+            UnauthorizedError: {};
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        pothosImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            builder: {};
+        }>>;
+        prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            PrismaClient: {};
+            Prisma: {};
+            '*': {};
+            $Enums: {};
+        }>>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        renderers: import("@baseplate-dev/sync").ProviderType<import("./generated/template-renderers.js").BetterAuthBetterAuthAdminModuleRenderers>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").BetterAuthBetterAuthAdminModulePaths>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators/src/index.js").AppModuleProvider>;
+        userObjectType: import("@baseplate-dev/sync").ProviderDependency<import("@baseplate-dev/fastify-generators/src/index.js").PothosTypeOutputProvider>;
+    }, any>;
+    nodePackages: import("@baseplate-dev/sync").AnyGeneratorTask;
+}>;
+//# sourceMappingURL=better-auth-admin-module.generator.d.ts.map