@baseplate-dev/plugin-auth 1.0.6 → 1.0.8

package/dist/local-auth/core/generators/auth-hooks/generated/template-renderers.d.ts

@@ -0,0 +1,35 @@
+import type { RenderTsTemplateGroupActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+import { LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES } from './typed-templates.js';
+export interface LocalAuthCoreAuthHooksRenderers {
+    hooksGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES.hooksGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+}
+export declare const LOCAL_AUTH_CORE_AUTH_HOOKS_RENDERERS: {
+    provider: import("@baseplate-dev/sync").ProviderType<LocalAuthCoreAuthHooksRenderers>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthHooksRenderers: import("@baseplate-dev/sync").ProviderExport<LocalAuthCoreAuthHooksRenderers>;
+    }, {
+        graphqlImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            '*': {};
+            graphql: {};
+            readFragment: {};
+            FragmentType: {
+                isTypeOnly: true;
+            };
+        }>>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthHooksPaths>;
+        reactErrorImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            formatError: {};
+            logAndFormatError: {};
+            logError: {};
+        }>>;
+        reactSessionImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionClient: {};
+            userSessionClient: {};
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-renderers.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/generated/template-renderers.js

@@ -0,0 +1,45 @@
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { graphqlImportsProvider, reactErrorImportsProvider, } from '@baseplate-dev/react-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+import { reactSessionImportsProvider } from '#src/local-auth/core/generators/react-session/generated/ts-import-providers.js';
+import { LOCAL_AUTH_CORE_AUTH_HOOKS_PATHS } from './template-paths.js';
+import { LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES } from './typed-templates.js';
+const localAuthCoreAuthHooksRenderers = createProviderType('local-auth-core-auth-hooks-renderers');
+const localAuthCoreAuthHooksRenderersTask = createGeneratorTask({
+    dependencies: {
+        graphqlImports: graphqlImportsProvider,
+        paths: LOCAL_AUTH_CORE_AUTH_HOOKS_PATHS.provider,
+        reactErrorImports: reactErrorImportsProvider,
+        reactSessionImports: reactSessionImportsProvider,
+        typescriptFile: typescriptFileProvider,
+    },
+    exports: {
+        localAuthCoreAuthHooksRenderers: localAuthCoreAuthHooksRenderers.export(),
+    },
+    run({ graphqlImports, paths, reactErrorImports, reactSessionImports, typescriptFile, }) {
+        return {
+            providers: {
+                localAuthCoreAuthHooksRenderers: {
+                    hooksGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES.hooksGroup,
+                            paths,
+                            importMapProviders: {
+                                graphqlImports,
+                                reactErrorImports,
+                                reactSessionImports,
+                            },
+                            generatorPaths: paths,
+                            ...options,
+                        }),
+                    },
+                },
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_HOOKS_RENDERERS = {
+    provider: localAuthCoreAuthHooksRenderers,
+    task: localAuthCoreAuthHooksRenderersTask,
+};
+//# sourceMappingURL=template-renderers.js.map

package/dist/local-auth/core/generators/auth-hooks/generated/ts-import-providers.d.ts

@@ -0,0 +1,29 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+export declare const localAuthHooksImportsSchema: {
+    AuthSessionContext: {};
+};
+export type LocalAuthHooksImportsProvider = TsImportMapProviderFromSchema<typeof localAuthHooksImportsSchema>;
+export declare const localAuthHooksImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    AuthSessionContext: {};
+}>>;
+export declare const LOCAL_AUTH_CORE_AUTH_HOOKS_IMPORTS: {
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        authHooksImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            SessionData: {
+                isTypeOnly: true;
+            };
+            useLogOut: {};
+            useRequiredUserId: {};
+            useSession: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+        }>>;
+        localAuthHooksImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthSessionContext: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").LocalAuthCoreAuthHooksPaths>;
+    }, undefined>;
+};
+//# sourceMappingURL=ts-import-providers.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/generated/ts-import-providers.js

@@ -0,0 +1,37 @@
+import { createTsImportMap, createTsImportMapSchema, packageScope, } from '@baseplate-dev/core-generators';
+import { authHooksImportsProvider, authHooksImportsSchema, } from '@baseplate-dev/react-generators';
+import { createGeneratorTask, createReadOnlyProviderType, } from '@baseplate-dev/sync';
+import { LOCAL_AUTH_CORE_AUTH_HOOKS_PATHS } from './template-paths.js';
+export const localAuthHooksImportsSchema = createTsImportMapSchema({
+    AuthSessionContext: {},
+});
+export const localAuthHooksImportsProvider = createReadOnlyProviderType('local-auth-hooks-imports');
+const localAuthCoreAuthHooksImportsTask = createGeneratorTask({
+    dependencies: {
+        paths: LOCAL_AUTH_CORE_AUTH_HOOKS_PATHS.provider,
+    },
+    exports: {
+        authHooksImports: authHooksImportsProvider.export(packageScope),
+        localAuthHooksImports: localAuthHooksImportsProvider.export(packageScope),
+    },
+    run({ paths }) {
+        return {
+            providers: {
+                authHooksImports: createTsImportMap(authHooksImportsSchema, {
+                    AuthRole: paths.useSession,
+                    SessionData: paths.useSession,
+                    useLogOut: paths.useLogOut,
+                    useRequiredUserId: paths.useRequiredUserId,
+                    useSession: paths.useSession,
+                }),
+                localAuthHooksImports: createTsImportMap(localAuthHooksImportsSchema, {
+                    AuthSessionContext: paths.useSession,
+                }),
+            },
+        };
+    },
+});
+export const LOCAL_AUTH_CORE_AUTH_HOOKS_IMPORTS = {
+    task: localAuthCoreAuthHooksImportsTask,
+};
+//# sourceMappingURL=ts-import-providers.js.map

package/dist/local-auth/core/generators/auth-hooks/generated/typed-templates.d.ts

@@ -0,0 +1,71 @@
+export declare const hooksGroup: {
+    useLogOut: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        graphqlImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            '*': {};
+            graphql: {};
+            readFragment: {};
+            FragmentType: {
+                isTypeOnly: true;
+            };
+        }>>;
+        reactErrorImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            formatError: {};
+            logAndFormatError: {};
+            logError: {};
+        }>>;
+        reactSessionImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionClient: {};
+            userSessionClient: {};
+        }>>;
+    }, Record<never, Record<never, never>>>;
+    useRequiredUserId: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, {
+        useSession: {};
+    }>;
+    useSession: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        graphqlImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            '*': {};
+            graphql: {};
+            readFragment: {};
+            FragmentType: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, Record<never, Record<never, never>>>;
+};
+export declare const LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES: {
+    hooksGroup: {
+        useLogOut: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            graphqlImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                '*': {};
+                graphql: {};
+                readFragment: {};
+                FragmentType: {
+                    isTypeOnly: true;
+                };
+            }>>;
+            reactErrorImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                formatError: {};
+                logAndFormatError: {};
+                logError: {};
+            }>>;
+            reactSessionImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                UserSessionClient: {};
+                userSessionClient: {};
+            }>>;
+        }, Record<never, Record<never, never>>>;
+        useRequiredUserId: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, {
+            useSession: {};
+        }>;
+        useSession: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+            graphqlImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                '*': {};
+                graphql: {};
+                readFragment: {};
+                FragmentType: {
+                    isTypeOnly: true;
+                };
+            }>>;
+        }, Record<never, Record<never, never>>>;
+    };
+};
+//# sourceMappingURL=typed-templates.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/generated/typed-templates.js

@@ -0,0 +1,50 @@
+import { createTsTemplateFile } from '@baseplate-dev/core-generators';
+import { graphqlImportsProvider, reactErrorImportsProvider, } from '@baseplate-dev/react-generators';
+import path from 'node:path';
+import { reactSessionImportsProvider } from '#src/local-auth/core/generators/react-session/generated/ts-import-providers.js';
+const useLogOut = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'hooks',
+    importMapProviders: {
+        graphqlImports: graphqlImportsProvider,
+        reactErrorImports: reactErrorImportsProvider,
+        reactSessionImports: reactSessionImportsProvider,
+    },
+    name: 'use-log-out',
+    projectExports: { useLogOut: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/hooks/use-log-out.ts'),
+    },
+    variables: {},
+});
+const useRequiredUserId = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'hooks',
+    importMapProviders: {},
+    name: 'use-required-user-id',
+    projectExports: { useRequiredUserId: {} },
+    referencedGeneratorTemplates: { useSession: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/hooks/use-user-id-or-throw.ts'),
+    },
+    variables: {},
+});
+const useSession = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'hooks',
+    importMapProviders: { graphqlImports: graphqlImportsProvider },
+    name: 'use-session',
+    projectExports: {
+        AuthRole: {},
+        AuthSessionContext: {},
+        SessionData: { isTypeOnly: true },
+        useSession: {},
+    },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/hooks/use-session.ts'),
+    },
+    variables: {},
+});
+export const hooksGroup = { useLogOut, useRequiredUserId, useSession };
+export const LOCAL_AUTH_CORE_AUTH_HOOKS_TEMPLATES = { hooksGroup };
+//# sourceMappingURL=typed-templates.js.map

package/dist/local-auth/core/generators/auth-hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './auth-hooks.generator.js';
+export type { LocalAuthHooksImportsProvider } from './generated/ts-import-providers.js';
+export { localAuthHooksImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/index.js

@@ -0,0 +1,3 @@
+export * from './auth-hooks.generator.js';
+export { localAuthHooksImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.js.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-log-out.d.ts

@@ -0,0 +1,3 @@
+export declare const logOutMutationDocument: any;
+export declare function useLogOut(): () => void;
+//# sourceMappingURL=use-log-out.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-log-out.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { graphql } from '%graphqlImports';
+import { logAndFormatError, logError } from '%reactErrorImports';
+import { userSessionClient } from '%reactSessionImports';
+import { useMutation } from '@apollo/client/react';
+import { useNavigate } from '@tanstack/react-router';
+import { toast } from 'sonner';
+export const logOutMutationDocument = graphql(`
+  mutation LogOut {
+    logOut {
+      success
+    }
+  }
+`);
+export function useLogOut() {
+    const [logOut] = useMutation(logOutMutationDocument);
+    const navigate = useNavigate();
+    return () => {
+        logOut()
+            .then(() => {
+            userSessionClient.signOut();
+            toast.success('You have been successfully logged out!');
+            navigate({ to: '/' }).catch(logError);
+        })
+            .catch((err) => {
+            toast.error(logAndFormatError(err, 'Sorry, we could not log you out.'));
+        });
+    };
+}
+//# sourceMappingURL=use-log-out.js.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-log-out.ts

@@ -0,0 +1,33 @@
+// @ts-nocheck
+
+import { graphql } from '%graphqlImports';
+import { logAndFormatError, logError } from '%reactErrorImports';
+import { userSessionClient } from '%reactSessionImports';
+import { useMutation } from '@apollo/client/react';
+import { useNavigate } from '@tanstack/react-router';
+import { toast } from 'sonner';
+
+export const logOutMutationDocument = graphql(`
+  mutation LogOut {
+    logOut {
+      success
+    }
+  }
+`);
+
+export function useLogOut(): () => void {
+  const [logOut] = useMutation(logOutMutationDocument);
+  const navigate = useNavigate();
+
+  return () => {
+    logOut()
+      .then(() => {
+        userSessionClient.signOut();
+        toast.success('You have been successfully logged out!');
+        navigate({ to: '/' }).catch(logError);
+      })
+      .catch((err: unknown) => {
+        toast.error(logAndFormatError(err, 'Sorry, we could not log you out.'));
+      });
+  };
+}

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-session.d.ts

@@ -0,0 +1,15 @@
+import type { AuthRole } from '%graphqlImports';
+export interface SessionData {
+    userId: string | undefined;
+    isAuthenticated: boolean;
+    roles: AuthRole[];
+}
+export declare const AuthSessionContext: import("react").Context<SessionData | undefined>;
+/**
+ * Provides the current session data such as the user id and whether the user is authenticated
+ * This is the primary hook for accessing authentication state
+ * @returns Current session data with computed isAuthenticated
+ */
+export declare function useSession(): SessionData;
+export type { AuthRole } from '@src/gql/graphql';
+//# sourceMappingURL=use-session.d.ts.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-session.js

@@ -0,0 +1,16 @@
+// @ts-nocheck
+import { createContext, useContext } from 'react';
+export const AuthSessionContext = createContext(undefined);
+/**
+ * Provides the current session data such as the user id and whether the user is authenticated
+ * This is the primary hook for accessing authentication state
+ * @returns Current session data with computed isAuthenticated
+ */
+export function useSession() {
+    const contextValue = useContext(AuthSessionContext);
+    if (!contextValue) {
+        throw new Error('useSession must be used within a AuthSessionProvider');
+    }
+    return contextValue;
+}
+//# sourceMappingURL=use-session.js.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-session.ts

@@ -0,0 +1,32 @@
+// @ts-nocheck
+
+import type { AuthRole } from '%graphqlImports';
+
+import { createContext, useContext } from 'react';
+
+export interface SessionData {
+  userId: string | undefined;
+  isAuthenticated: boolean;
+  roles: AuthRole[];
+}
+
+export const AuthSessionContext = createContext<SessionData | undefined>(
+  undefined,
+);
+
+/**
+ * Provides the current session data such as the user id and whether the user is authenticated
+ * This is the primary hook for accessing authentication state
+ * @returns Current session data with computed isAuthenticated
+ */
+export function useSession(): SessionData {
+  const contextValue = useContext(AuthSessionContext);
+
+  if (!contextValue) {
+    throw new Error('useSession must be used within a AuthSessionProvider');
+  }
+
+  return contextValue;
+}
+
+export type { AuthRole } from '@src/gql/graphql';

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-user-id-or-throw.js

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { useSession } from '$useSession';
+/**
+ * Provides the current user id or throws an error if the user is not authenticated
+ * @returns Current user ID
+ * @throws Error if user is not authenticated
+ */
+export function useUserIdOrThrow() {
+    const session = useSession();
+    if (!session.userId) {
+        throw new Error('User not authenticated');
+    }
+    return session.userId;
+}
+//# sourceMappingURL=use-user-id-or-throw.js.map

package/dist/local-auth/core/generators/auth-hooks/templates/src/hooks/use-user-id-or-throw.ts

@@ -0,0 +1,16 @@
+// @ts-nocheck
+
+import { useSession } from '$useSession';
+
+/**
+ * Provides the current user id or throws an error if the user is not authenticated
+ * @returns Current user ID
+ * @throws Error if user is not authenticated
+ */
+export function useUserIdOrThrow(): string {
+  const session = useSession();
+  if (!session.userId) {
+    throw new Error('User not authenticated');
+  }
+  return session.userId;
+}

package/dist/local-auth/core/generators/auth-module/auth-module.generator.d.ts

@@ -0,0 +1,179 @@
+export declare const authModuleGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    userAdminRoles?: string[] | undefined;
+    devWebPorts?: number[] | undefined;
+}, {
+    paths: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthModulePaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").LocalAuthCoreAuthModulePaths>;
+    }, {
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+    }, undefined>;
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        authModuleImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            cleanupAuthVerificationQueue: {};
+            cleanupAuthVerificationWorker: {};
+            cleanupExpiredAuthVerifications: {};
+            CookieUserSessionService: {};
+            createAuthVerification: {};
+            userSessionPayload: {};
+            validateAuthVerification: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").LocalAuthCoreAuthModulePaths>;
+    }, undefined>;
+    renderers: import("@baseplate-dev/sync").GeneratorTask<{
+        localAuthCoreAuthModuleRenderers: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-renderers.js").LocalAuthCoreAuthModuleRenderers>;
+    }, {
+        authContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AuthContext: {
+                isTypeOnly: true;
+            };
+            AuthSessionInfo: {
+                isTypeOnly: true;
+            };
+            AuthUserSessionInfo: {
+                isTypeOnly: true;
+            };
+            createAnonymousAuthContext: {};
+            createAuthContextFromSessionInfo: {};
+            createSystemAuthContext: {};
+            InvalidSessionError: {};
+        }>>;
+        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;
+            };
+        }>>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            getConfig: {};
+            isDevelopment: {};
+        }>>;
+        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").LocalAuthCoreAuthModulePaths>;
+        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: {};
+        }>>;
+        queuesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            bindQueueHandler: {};
+            DEFAULT_QUEUE_CONCURRENCY: {};
+            defineQueue: {};
+            EnqueueOptions: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBinding: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingConfig: {
+                isTypeOnly: true;
+            };
+            QueueHandlerBindingInput: {
+                isTypeOnly: true;
+            };
+            QueueInfo: {
+                isTypeOnly: true;
+            };
+            QueueIntrospection: {
+                isTypeOnly: true;
+            };
+            QueueJob: {
+                isTypeOnly: true;
+            };
+            QueueJobHandler: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixPlan: {
+                isTypeOnly: true;
+            };
+            QueuePolicyFixResult: {
+                isTypeOnly: true;
+            };
+            QueueRuntime: {
+                isTypeOnly: true;
+            };
+            QueueService: {
+                isTypeOnly: true;
+            };
+            QueueToken: {
+                isTypeOnly: true;
+            };
+            QueueWorkers: {
+                isTypeOnly: true;
+            };
+            RepeatableConfig: {
+                isTypeOnly: true;
+            };
+            ScheduledJob: {
+                isTypeOnly: true;
+            };
+        }>>;
+        requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createContextFromRequest: {};
+            RequestServiceContext: {
+                isTypeOnly: true;
+            };
+            RequestServiceContextWith: {
+                isTypeOnly: true;
+            };
+        }>>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        userSessionTypesImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            UserSessionPayload: {
+                isTypeOnly: true;
+            };
+            UserSessionService: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, undefined>;
+    config: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        provider: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            configFields: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").ConfigServiceField>;
+        }>, "getValues">>;
+    }, undefined>;
+    appModule: import("@baseplate-dev/sync").GeneratorTask<any, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").LocalAuthCoreAuthModulePaths>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+    }, any>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        prismaOutput: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").PrismaOutputProvider>;
+        renderers: import("@baseplate-dev/sync").ProviderType<import("./generated/template-renderers.js").LocalAuthCoreAuthModuleRenderers>;
+        userObjectType: import("@baseplate-dev/sync").ProviderDependency<import("@baseplate-dev/fastify-generators").PothosTypeOutputProvider>;
+        appModule: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/fastify-generators").AppModuleProvider>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").LocalAuthCoreAuthModulePaths>;
+    }, any>;
+    appRuntimeConfig: import("@baseplate-dev/sync").GeneratorTask<any, {
+        appRuntimeConfig: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            services: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").AppRuntimeServiceEntry>;
+            construction: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/fastify-generators").AppRuntimeConstructionEntry>;
+            flattenedModuleFields: import("@baseplate-dev/utils").MapContainer<string, string>;
+            usesBackgroundServices: import("@baseplate-dev/utils").ScalarContainer<boolean | undefined>;
+        }>, "getValues">>;
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").LocalAuthCoreAuthModulePaths>;
+    }, any>;
+}>;
+//# sourceMappingURL=auth-module.generator.d.ts.map