@guren/server 0.1.1-alpha.0

package/dist/chunk-GDCUIM6V.js

@@ -0,0 +1,121 @@
+// src/vite/plugin.ts
+import path from "path";
+var defaultOptions = {
+  appAlias: "@",
+  appDir: "app",
+  resourcesAlias: "@resources",
+  resourcesDir: "resources/js",
+  entry: "resources/js/app.tsx",
+  outDir: "public/assets",
+  devPort: 5173,
+  previewPort: 4173,
+  entryFileNames: "[name]-[hash].js",
+  chunkFileNames: "[name]-[hash].js",
+  assetFileNames: "[name]-[hash][extname]"
+};
+function gurenVitePlugin(options = {}) {
+  const resolved = { ...defaultOptions, ...options };
+  return {
+    name: "guren:vite-config",
+    enforce: "pre",
+    config(config, _env) {
+      ensureDefaults(config, resolved);
+    }
+  };
+}
+function ensureDefaults(config, options) {
+  const root = resolveRoot(config.root);
+  ensureAliases(config, options, root);
+  ensureServer(config, options);
+  ensurePreview(config, options);
+  ensureBuild(config, options, root);
+}
+function ensureAliases(config, options, root) {
+  config.resolve ??= {};
+  const alias = toAliasArray(config.resolve.alias);
+  maybePushAlias(alias, options.appAlias, path.resolve(root, options.appDir));
+  maybePushAlias(alias, options.resourcesAlias, path.resolve(root, options.resourcesDir));
+  config.resolve.alias = alias;
+}
+function ensureServer(config, options) {
+  config.server ??= {};
+  if (config.server.host === void 0) {
+    config.server.host = true;
+  }
+  if (config.server.port === void 0) {
+    config.server.port = options.devPort;
+  }
+}
+function ensurePreview(config, options) {
+  config.preview ??= {};
+  if (config.preview.host === void 0) {
+    config.preview.host = true;
+  }
+  if (config.preview.port === void 0) {
+    config.preview.port = options.previewPort;
+  }
+}
+function ensureBuild(config, options, root) {
+  config.build ??= {};
+  if (config.build.outDir === void 0) {
+    config.build.outDir = options.outDir;
+  }
+  if (config.build.emptyOutDir === void 0) {
+    config.build.emptyOutDir = true;
+  }
+  if (config.build.manifest === void 0) {
+    config.build.manifest = true;
+  }
+  config.build.rollupOptions ??= {};
+  if (config.build.rollupOptions.input === void 0) {
+    config.build.rollupOptions.input = path.resolve(root, options.entry);
+  }
+  const output = normalizeRollupOutput(config.build.rollupOptions.output);
+  if (output.entryFileNames === void 0) {
+    output.entryFileNames = options.entryFileNames;
+  }
+  if (output.chunkFileNames === void 0) {
+    output.chunkFileNames = options.chunkFileNames;
+  }
+  if (output.assetFileNames === void 0) {
+    output.assetFileNames = options.assetFileNames;
+  }
+  config.build.rollupOptions.output = output;
+}
+function resolveRoot(root) {
+  if (!root) {
+    return process.cwd();
+  }
+  return path.isAbsolute(root) ? root : path.resolve(process.cwd(), root);
+}
+function toAliasArray(alias) {
+  if (Array.isArray(alias)) {
+    return alias.slice();
+  }
+  if (alias && typeof alias === "object") {
+    return Object.entries(alias).map(([find, replacement]) => ({
+      find,
+      replacement
+    }));
+  }
+  return [];
+}
+function maybePushAlias(alias, find, replacement) {
+  const alreadyDefined = alias.some((entry) => entry.find === find);
+  if (!alreadyDefined) {
+    alias.push({ find, replacement });
+  }
+}
+function normalizeRollupOutput(output) {
+  if (Array.isArray(output)) {
+    if (output.length === 0) {
+      return {};
+    }
+    return output[0];
+  }
+  return output ?? {};
+}
+
+export {
+  gurenVitePlugin
+};

package/dist/index.d.ts

@@ -0,0 +1,493 @@
+import * as hono from 'hono';
+import { MiddlewareHandler, Context, Hono, ExecutionContext } from 'hono';
+export { Context } from 'hono';
+export { GurenVitePluginOptions, default as gurenVitePlugin } from './vite/index.js';
+
+interface InertiaOptions {
+    readonly url?: string;
+    readonly version?: string;
+    readonly status?: number;
+    readonly headers?: HeadersInit;
+    readonly request?: Request;
+    readonly title?: string;
+    readonly entry?: string;
+    readonly importMap?: Record<string, string>;
+    readonly styles?: string[];
+}
+interface InertiaPagePayload {
+    component: string;
+    props: Record<string, unknown>;
+    url: string;
+    version?: string;
+}
+declare function inertia(component: string, props: Record<string, unknown>, options?: InertiaOptions): Response;
+
+type SessionData = Record<string, unknown>;
+interface SessionStore {
+    read(id: string): Promise<SessionData | undefined>;
+    write(id: string, data: SessionData, ttlSeconds: number): Promise<void>;
+    destroy(id: string): Promise<void>;
+}
+declare class MemorySessionStore implements SessionStore {
+    private readonly now;
+    private readonly store;
+    constructor(now?: () => number);
+    read(id: string): Promise<SessionData | undefined>;
+    write(id: string, data: SessionData, ttlSeconds: number): Promise<void>;
+    destroy(id: string): Promise<void>;
+}
+interface SessionOptions {
+    cookieName?: string;
+    cookiePath?: string;
+    cookieDomain?: string;
+    cookieSecure?: boolean;
+    cookieSameSite?: 'Strict' | 'Lax' | 'None';
+    cookieHttpOnly?: boolean;
+    cookieMaxAgeSeconds?: number;
+    ttlSeconds?: number;
+    store?: SessionStore;
+}
+interface Session {
+    readonly id: string;
+    readonly isNew: boolean;
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T): void;
+    has(key: string): boolean;
+    forget(key: string): void;
+    flush(): void;
+    all(): SessionData;
+    regenerate(): void;
+    invalidate(): void;
+}
+interface CreateSessionMiddlewareOptions extends SessionOptions {
+}
+declare function createSessionMiddleware(options?: CreateSessionMiddlewareOptions): MiddlewareHandler;
+declare function getSessionFromContext<T extends Session = Session>(ctx: {
+    get: (key: string) => unknown;
+}): T | undefined;
+
+interface RequireAuthOptions {
+    redirectTo?: string;
+    status?: number;
+    responseFactory?: () => Response;
+}
+declare function attachAuthContext(contextFactory: (ctx: Context) => AuthContext): MiddlewareHandler;
+declare function requireAuthenticated(options?: RequireAuthOptions): MiddlewareHandler;
+declare function requireGuest(options?: RequireAuthOptions): MiddlewareHandler;
+
+type Middleware = MiddlewareHandler;
+declare function defineMiddleware(handler: MiddlewareHandler): MiddlewareHandler;
+
+type AuthCredentials = Record<string, unknown>;
+interface Authenticatable {
+    getAuthIdentifier(): unknown;
+    getAuthPassword(): string | null | undefined;
+    getRememberToken?(): string | null | undefined;
+    setRememberToken?(token: string | null): void | Promise<void>;
+}
+interface Guard<User = Authenticatable> {
+    check(): Promise<boolean>;
+    guest(): Promise<boolean>;
+    user<T = User>(): Promise<T | null>;
+    id(): Promise<unknown>;
+    login<T = User>(user: T, remember?: boolean): Promise<void>;
+    logout(): Promise<void>;
+    attempt(credentials: AuthCredentials, remember?: boolean): Promise<boolean>;
+    validate(credentials: AuthCredentials): Promise<User | null>;
+    session<T extends Session = Session>(): T | undefined;
+}
+interface UserProvider<User = Authenticatable> {
+    retrieveById(identifier: unknown): Promise<User | null>;
+    retrieveByCredentials(credentials: AuthCredentials): Promise<User | null>;
+    validateCredentials(user: User, credentials: AuthCredentials): Promise<boolean>;
+    getId(user: User): unknown;
+    setRememberToken?(user: User, token: string | null): Promise<void> | void;
+    getRememberToken?(user: User): Promise<string | null> | string | null;
+}
+interface GuardContext {
+    ctx: Context;
+    session: Session | undefined;
+    manager: AuthManagerContract;
+}
+type GuardFactory<User = Authenticatable> = (context: GuardContext) => Guard<User>;
+interface ProviderFactory<User = Authenticatable> {
+    (manager: AuthManagerContract): UserProvider<User>;
+}
+interface AuthManagerOptions {
+    defaultGuard?: string;
+}
+interface AttachContextOptions {
+    guard?: string;
+}
+interface AuthContext<User = Authenticatable> {
+    check(): Promise<boolean>;
+    guest(): Promise<boolean>;
+    user<T = User>(): Promise<T | null>;
+    id(): Promise<unknown>;
+    login<T = User>(user: T, remember?: boolean): Promise<void>;
+    attempt(credentials: AuthCredentials, remember?: boolean): Promise<boolean>;
+    logout(): Promise<void>;
+    guard<T = User>(name?: string): Guard<T>;
+    session<T extends Session = Session>(): T | undefined;
+}
+interface AuthManagerContract {
+    registerGuard<User = Authenticatable>(name: string, factory: GuardFactory<User>): void;
+    registerProvider<User = Authenticatable>(name: string, factory: ProviderFactory<User>): void;
+    getProvider<User = Authenticatable>(name: string): UserProvider<User>;
+    createGuard<User = Authenticatable>(name: string, context: GuardContext): Guard<User>;
+    guardNames(): string[];
+    setDefaultGuard(name: string): void;
+    getDefaultGuard(): string;
+    createAuthContext(ctx: Context, options?: AttachContextOptions): AuthContext;
+}
+
+declare class AuthManager implements AuthManagerContract {
+    private readonly guards;
+    private readonly providers;
+    private defaultGuard;
+    constructor(options?: AuthManagerOptions);
+    registerGuard<User>(name: string, factory: GuardFactory<User>): void;
+    registerProvider<User>(name: string, factory: ProviderFactory<User>): void;
+    getProvider<User>(name: string): UserProvider<User>;
+    createGuard<User>(name: string, context: GuardContext): Guard<User>;
+    guardNames(): string[];
+    setDefaultGuard(name: string): void;
+    getDefaultGuard(): string;
+    createAuthContext(ctx: Context, options?: AttachContextOptions): AuthContext;
+    attempt(name: string, ctx: Context, credentials: AuthCredentials, remember?: boolean): Promise<boolean>;
+}
+
+interface SessionGuardOptions {
+    provider: UserProvider;
+    sessionKey?: string;
+    rememberSessionKey?: string;
+    session: Session | undefined;
+}
+declare class SessionGuard<User extends Authenticatable = Authenticatable> implements Guard<User> {
+    private readonly options;
+    private cachedUser;
+    constructor(options: SessionGuardOptions);
+    private get currentSession();
+    private get provider();
+    private sessionKey;
+    private rememberSessionKey;
+    private loadRememberedUser;
+    private resolveUser;
+    check(): Promise<boolean>;
+    guest(): Promise<boolean>;
+    user<T = User>(): Promise<T | null>;
+    id(): Promise<unknown>;
+    private remember;
+    login<T = User>(user: T, remember?: boolean): Promise<void>;
+    logout(): Promise<void>;
+    attempt(credentials: AuthCredentials, remember?: boolean): Promise<boolean>;
+    validate(credentials: AuthCredentials): Promise<User | null>;
+    session<T extends Session = Session>(): T | undefined;
+}
+
+declare abstract class BaseUserProvider<User extends Authenticatable = Authenticatable> implements UserProvider<User> {
+    abstract retrieveById(identifier: unknown): Promise<User | null>;
+    abstract retrieveByCredentials(credentials: AuthCredentials): Promise<User | null>;
+    abstract validateCredentials(user: User, credentials: AuthCredentials): Promise<boolean>;
+    abstract getId(user: User): unknown;
+    setRememberToken(user: User, token: string | null): Promise<void>;
+    getRememberToken(user: User): Promise<string | null>;
+}
+
+type PlainObject = Record<string, unknown>;
+type WhereClause = Record<string, unknown>;
+interface ORMAdapter {
+    findMany<TRecord = PlainObject>(table: unknown, where?: WhereClause): Promise<TRecord[]>;
+    findUnique<TRecord = PlainObject>(table: unknown, where: WhereClause): Promise<TRecord | null>;
+    create<TRecord = PlainObject>(table: unknown, data: PlainObject): Promise<TRecord>;
+    update?<TRecord = PlainObject>(table: unknown, where: WhereClause, data: PlainObject): Promise<TRecord>;
+    delete?<TRecord = PlainObject>(table: unknown, where: WhereClause): Promise<number | PlainObject | void>;
+}
+/**
+ * Minimal ActiveRecord-like wrapper around the configured ORM adapter. The API
+ * mirrors a subset of Laravel's Eloquent helpers and can be expanded over time.
+ */
+declare abstract class Model<TRecord extends object = PlainObject> {
+    protected static ormAdapter: ORMAdapter;
+    protected static table: unknown;
+    static readonly recordType: unknown;
+    static useAdapter(adapter: ORMAdapter): void;
+    static getAdapter(): ORMAdapter;
+    protected static resolveTable(): unknown;
+    static all<T extends typeof Model>(this: T): Promise<Array<TRecordFor<T>>>;
+    static find<T extends typeof Model>(this: T, id: unknown, key?: string): Promise<TRecordFor<T> | null>;
+    static where<T extends typeof Model>(this: T, where: WhereClause): Promise<TRecordFor<T>[]>;
+    static create<T extends typeof Model>(this: T, data: PlainObject): Promise<TRecordFor<T>>;
+    static update<T extends typeof Model>(this: T, where: WhereClause, data: PlainObject): Promise<TRecordFor<T>>;
+    static delete<T extends typeof Model>(this: T, where: WhereClause): Promise<number | PlainObject | void>;
+}
+type TRecordFor<T extends typeof Model> = T extends {
+    recordType: infer R;
+} ? R extends object ? R : PlainObject : PlainObject;
+
+interface PasswordHasher {
+    hash(plain: string): Promise<string>;
+    verify(hashed: string, plain: string): Promise<boolean>;
+    needsRehash?(hashed: string): boolean;
+}
+
+interface ModelUserProviderOptions {
+    idColumn?: string;
+    usernameColumn?: string;
+    passwordColumn?: string;
+    rememberTokenColumn?: string;
+    hasher?: PasswordHasher;
+    credentialsPasswordField?: string;
+}
+declare class ModelUserProvider<User extends Authenticatable = Authenticatable> extends BaseUserProvider<User> {
+    private readonly model;
+    private readonly idColumn;
+    private readonly usernameColumn;
+    private readonly passwordColumn;
+    private readonly rememberTokenColumn;
+    private readonly hasher;
+    private readonly credentialsPasswordField;
+    constructor(model: typeof Model, options?: ModelUserProviderOptions);
+    private cast;
+    retrieveById(identifier: unknown): Promise<User | null>;
+    retrieveByCredentials(credentials: AuthCredentials): Promise<User | null>;
+    validateCredentials(user: User, credentials: AuthCredentials): Promise<boolean>;
+    getId(user: User): unknown;
+    setRememberToken(user: User, token: string | null): Promise<void>;
+    getRememberToken(user: User): Promise<string | null>;
+}
+
+type Argon2Algorithm = 'argon2id' | 'argon2i' | 'argon2d';
+type SupportedAlgorithm = Argon2Algorithm | 'bcrypt';
+interface BunPasswordHasherOptions {
+    /**
+     * Hashing algorithm to use. Defaults to Bun's Argon2id implementation.
+     */
+    algorithm?: SupportedAlgorithm;
+    /** Argon2 memory cost (in kibibytes). */
+    memoryCost?: number;
+    /** Argon2 time cost (number of iterations). */
+    timeCost?: number;
+    /** Bcrypt cost factor (log rounds). */
+    cost?: number;
+}
+declare class ScryptHasher implements PasswordHasher {
+    private readonly algorithm;
+    private readonly memoryCost?;
+    private readonly timeCost?;
+    private readonly cost?;
+    constructor(options?: BunPasswordHasherOptions);
+    hash(plain: string): Promise<string>;
+    verify(hashed: string, plain: string): Promise<boolean>;
+    needsRehash(hashed: string): boolean;
+}
+
+type DefaultInertiaProps = Record<string, unknown>;
+type InertiaResponseMarker<Component extends string, Props extends DefaultInertiaProps> = {
+    readonly __gurenInertia?: {
+        readonly component: Component;
+        readonly props: Props;
+    };
+};
+type InertiaResponse<Component extends string, Props extends DefaultInertiaProps> = Response & InertiaResponseMarker<Component, Props>;
+type InferInertiaProps<T> = [T] extends [InertiaResponse<string, infer Props>] ? Props : [T] extends [Promise<infer Awaited>] ? InferInertiaProps<Awaited> : DefaultInertiaProps;
+interface RedirectOptions {
+    status?: number;
+    headers?: HeadersInit;
+}
+type InertiaResponseOptions = Omit<InertiaOptions, 'url' | 'request'> & {
+    url?: string;
+};
+/**
+ * Base controller inspired by Laravel's expressive API. Subclasses can access
+ * the current Hono context through the protected `ctx` getter and rely on the
+ * helper response builders for common patterns.
+ */
+declare class Controller {
+    private context?;
+    setContext(context: Context): void;
+    protected get ctx(): Context;
+    protected get request(): hono.HonoRequest<any, unknown>;
+    protected get auth(): AuthContext;
+    protected inertia<Component extends string, Props extends DefaultInertiaProps>(component: Component, props: Props, options?: InertiaResponseOptions): InertiaResponse<Component, Props>;
+    protected json<T>(data: T, init?: ResponseInit): Response;
+    protected text(body: string, init?: ResponseInit): Response;
+    protected redirect(url: string, options?: RedirectOptions): Response;
+}
+
+type ControllerConstructor<T extends Controller = Controller> = new () => T;
+type ControllerMethod<T extends Controller> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T] & string;
+type ControllerAction<T extends Controller = Controller> = [ControllerConstructor<T>, ControllerMethod<T>];
+type RouteResult = Response | string | number | boolean | Record<string, unknown> | Array<unknown> | null | void;
+type RouteHandler<T extends Controller = Controller> = ((c: Context) => RouteResult | Promise<RouteResult>) | ControllerAction<T>;
+interface RouteDefinition {
+    method: string;
+    path: string;
+    name?: string;
+}
+/**
+ * Route registry stores Laravel-style route declarations and eagerly mounts
+ * them onto a Hono instance when requested.
+ */
+declare class Route {
+    private static readonly registry;
+    private static readonly prefixStack;
+    private static add;
+    static on<T extends Controller>(method: string, path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static get<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static post<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static put<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static patch<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static delete<T extends Controller>(path: string, handler: RouteHandler<T>, ...middlewares: MiddlewareHandler[]): typeof Route;
+    static group(prefix: string, callback: () => void): typeof Route;
+    static mount(app: Hono): void;
+    static clear(): void;
+    static definitions(): RouteDefinition[];
+}
+
+type ViewRenderer = (template: string, props: Record<string, unknown>) => Response;
+/**
+ * Registry for view renderers. Engines are typically registered via service
+ * providers so applications can opt into or replace implementations.
+ */
+declare class ViewEngine {
+    private static readonly engines;
+    static register(name: string, renderer: ViewRenderer): void;
+    static has(name: string): boolean;
+    static render(name: string, template: string, props: Record<string, unknown>): Response;
+}
+
+declare class ApplicationContext {
+    private readonly application;
+    private readonly authManager;
+    constructor(application: Application, authManager: AuthManager);
+    get app(): Application;
+    get hono(): Hono;
+    get routes(): typeof Route;
+    get views(): typeof ViewEngine;
+    get auth(): AuthManager;
+}
+
+interface Provider {
+    register?(context: ApplicationContext): void | Promise<void>;
+    boot?(context: ApplicationContext): void | Promise<void>;
+}
+type ProviderConstructor<T extends Provider = Provider> = new () => T;
+
+type BootCallback = (app: Hono) => void | Promise<void>;
+interface ApplicationOptions {
+    readonly boot?: BootCallback;
+    readonly providers?: Array<Provider | ProviderConstructor>;
+}
+/**
+ * Application wires the Route registry into a running Hono instance.
+ * It offers a small convenience layer so users can bootstrap a Bun server
+ * without touching the underlying Hono object directly.
+ */
+declare class Application {
+    private readonly options;
+    readonly hono: Hono;
+    private readonly plugins;
+    private context?;
+    private readonly authManager;
+    constructor(options?: ApplicationOptions);
+    get auth(): AuthManager;
+    /**
+     * Mounts all routes that were defined through the Route DSL.
+     */
+    mountRoutes(): void;
+    /**
+     * Allows registering global middlewares directly on the underlying Hono app.
+     */
+    use(path: string, ...middleware: MiddlewareHandler[]): void;
+    /**
+     * Executes the optional boot callback and mounts the registered routes.
+     */
+    boot(): Promise<void>;
+    /**
+     * Fetch handler to integrate with Bun.serve or any standard Fetch runtime.
+     */
+    fetch(request: Request, env?: unknown, executionCtx?: ExecutionContext): Promise<Response>;
+    /**
+     * Convenience helper to start a Bun server when available.
+     */
+    listen(options?: {
+        port?: number;
+        hostname?: string;
+    }): void;
+    register(provider: Provider | ProviderConstructor): this;
+    registerMany(providers: Array<Provider | ProviderConstructor>): this;
+    private resolveContext;
+    private registerDefaultProviders;
+}
+
+interface DevAssetsOptions {
+    /** Absolute path to the resources directory (e.g. `/app/resources`). */
+    resourcesDir?: string;
+    /** Base import meta used to resolve relative paths. */
+    importMeta?: ImportMeta;
+    /** Relative path from `importMeta` to the resources directory. Defaults to `../resources`. */
+    resourcesPath?: string;
+    /** Path prefix to mount transpiled JS assets. Defaults to `/resources/js`. */
+    prefix?: string;
+    /** Enables serving the bundled inertia client. Defaults to true. */
+    inertiaClient?: boolean;
+    /** Path to the inertia client source. Defaults to the version bundled with Guren. */
+    inertiaClientSource?: string;
+    /** Public URL for the inertia client. Defaults to `/vendor/inertia-client.tsx`. */
+    inertiaClientPath?: string;
+    /** Override the remote JSX runtime URL. */
+    jsxRuntimeUrl?: string;
+    /** Absolute path to a directory with static assets (e.g. `/app/public`). */
+    publicDir?: string;
+    /** Relative path from `importMeta` to the static assets directory. Defaults to `../public`. */
+    publicPath?: string | false;
+    /** Route pattern used when serving static assets. Defaults to `/public/*`. */
+    publicRoute?: string;
+    /** Whether to register a no-op favicon route. Defaults to true when static assets are served. */
+    favicon?: boolean;
+}
+/**
+ * Registers development asset serving middleware.
+ * @param app
+ * @param options
+ */
+declare function registerDevAssets(app: Application, options: DevAssetsOptions): void;
+
+interface InertiaAssetsOptions extends DevAssetsOptions {
+    /** Default stylesheet entry embedded into Inertia responses. */
+    stylesEntry?: string;
+    /** Default script entry embedded into Inertia responses (production). */
+    scriptEntry?: string;
+}
+declare function configureInertiaAssets(app: Application, options: InertiaAssetsOptions): void;
+
+/**
+ * Parses the incoming request payload supporting both JSON bodies and form submissions.
+ * Falls back to an empty object if the payload cannot be parsed.
+ */
+declare function parseRequestPayload(ctx: Context): Promise<Record<string, unknown>>;
+interface ValidationIssueLike {
+    path: Array<string | number>;
+    message: string;
+}
+interface ValidationErrorLike {
+    issues: ValidationIssueLike[];
+}
+/**
+ * Converts a Zod-style validation error into a flat record usable by forms.
+ */
+declare function formatValidationErrors(error: ValidationErrorLike, fallbackMessage?: string): Record<string, string>;
+
+declare class InertiaViewProvider implements Provider {
+    register(_context: ApplicationContext): void;
+}
+
+declare class AuthServiceProvider implements Provider {
+    register(context: ApplicationContext): void;
+    boot(context: ApplicationContext): void;
+}
+
+export { Application, ApplicationContext, type AuthContext, type AuthCredentials, AuthManager, type AuthManagerOptions, type AuthContext as AuthRuntimeContext, AuthServiceProvider, type Authenticatable, BaseUserProvider, Controller, type Guard, type GuardContext, type GuardFactory, type InertiaOptions, type InertiaPagePayload, type InertiaResponse, InertiaViewProvider, type InferInertiaProps, MemorySessionStore, type Middleware, ModelUserProvider, type Provider, type ProviderConstructor, type ProviderFactory, type RequireAuthOptions, Route, type RouteDefinition, ScryptHasher, type Session, type SessionData, SessionGuard, type SessionStore, type UserProvider, ViewEngine, attachAuthContext, configureInertiaAssets, createSessionMiddleware, defineMiddleware, formatValidationErrors, getSessionFromContext, inertia, parseRequestPayload, registerDevAssets, requireAuthenticated, requireGuest };