1) All these methods are in the @dxtmisha/nitro-basic library.
2) Everything that is exported can be used.
3) Use what is in this library if it exists; do not use other libraries if there is an analogue here. Do not create new ones if an analogue already exists here.

The following is the content of "exports" from package.json:
{
  ".": {
    "import": "./dist/library.js",
    "types": "./dist/library.d.ts"
  },
  "./plugin": {
    "import": "./dist/library-plugin.js",
    "types": "./dist/library-plugin.d.ts"
  },
  "./ai-types": "./ai-types.txt",
  "./style.css": "./dist/style.css",
  "./types/*": "./dist/*",
  "./types/**/*.d.ts": "./dist/**/*.d.ts"
}

// File: library-plugin.d.ts

/**
 * Initialize API cache.
 * @param storageKey Storage key prefix
 * @param cacheStepAgeClearOld Cache cleanup threshold
 */
export declare function initPluginApiCache(storageKey?: string, cacheStepAgeClearOld?: number): void;

/**
 * Initialize basic Nitro functions.
 * @param _ Nitro application instance
 * @param config Configuration
 */
export declare function initPluginBasic<N extends NitroApp & Record<string, any> = NitroApp>(_: N, config?: NitroAppBasicConfig): void;

/** Basic Nitro configuration. */
declare type NitroAppBasicConfig = {
    /** API cache configuration */
    api?: {
        /** Storage key prefix */
        cacheStorageKey?: string;
        /** Cache cleanup threshold */
        cacheStepAgeClearOld?: number;
    };
};

export { }

// File: library.d.ts

/**
 * Get origin from request URL.
 * @param request HTTP request
 */
export declare function getRequestOrigin(request: Request): string;

/**
 * Get pathname from request URL.
 * @param request HTTP request
 */
export declare function getRequestUrl(request: Request): string;

/**
 * Initialize API client for the current request.
 * @param request incoming server request
 */
export declare function initApi(request: Request): void;

/**
 * Wait for client-side router readiness.
 * @param router Vue Router instance
 */
export declare function initClientRouter(router: Router | undefined): Promise<void>;

/**
 * Initialize cookie storage plugin.
 * @param app Vue application instance
 * @param request HTTP request
 */
export declare function initCookieStorage<T>(app: App<T>, request: Request): void;

/**
 * Initialize and provide API headers.
 * @param app Root application component
 */
export declare function initHeaders<T>(app: App<T>): void;

/** Generate hydration JSON scripts. */
export declare function initScriptsJson(): string;

/**
 * Initialize router for the application.
 * @param request HTTP request
 * @param router Vue router instance
 */
export declare function initServerRouter(request: Request, router: Router | undefined): Promise<void>;

/**
 * Initialize server storage plugin.
 * @param app Vue application instance
 */
export declare function initServerStorage<T>(app: App<T>): void;

/**
 * Render Vue app to string and extract context.
 * @param app Vue application instance
 * @param context SSR context
 */
export declare function initSsrApp<T>(app: App<T>, context?: SSRContext): Promise<{
    appHtml: string;
    teleportsHtml: string;
    context: SSRContext;
}>;

/** Key for server headers in Vue context. */
export declare const NITRO_API_HEADERS = "__ui_server_headers";

/** Key for server cookie in Vue context. */
export declare const NITRO_APP_COOKIE = "__ui_server_cookie";

/** Key for server storage in Vue context. */
export declare const NITRO_APP_STORAGE = "__ui_server_storage";

/** Basic Nitro configuration. */
export declare type NitroAppBasicConfig = {
    /** API cache configuration */
    api?: {
        /** Storage key prefix */
        cacheStorageKey?: string;
        /** Cache cleanup threshold */
        cacheStepAgeClearOld?: number;
    };
};

/** Nitro app initialization options. */
export declare interface NitroAppOptions extends FunctionalPluginOptions {
    /** Router configuration */
    appRouter?: {
        /** Route records */
        routes: RouteRecordRaw[];
        /** Router options */
        options?: NitroAppRouterOptions;
    };
}

/** Partial router options. */
export declare type NitroAppRouterOptions = Partial<RouterOptions>;

/** Initialize global unique ID generator for client. */
export declare function uiBootstrapClient(): void;

/** Initialize server components and request handlers. */
export declare function uiBootstrapServer(): void;

/** Initialize cookie storage. */
export declare function uiCookieStorage(): void;

/**
 * Create Vue SSR app and core plugins.
 * @param appComponent Root component
 * @param options App configuration
 */
export declare function uiCreateApp<A = any>(appComponent: A, options?: NitroAppOptions): {
    app: App<Element>;
    router: Router | undefined;
    options: NitroAppOptions;
};

/**
 * Finalize and mount client-side Vue app.
 * @param app Vue application instance
 * @param rootContainer Mounting container
 * @param router Vue Router instance
 * @param options Configuration options
 * @param action Pre-mount action
 */
export declare function uiCreateClientApp<T>(app: App<T>, rootContainer?: string | T, router?: Router | undefined, options?: NitroAppOptions, action?: (app: App<T>) => Promise<void> | void): Promise<void>;

/**
 * Initialize server app, routing, and SSR rendering.
 * @param app Root component
 * @param request Server request
 * @param router Optional router
 * @param options Configuration options
 * @param action Pre-rendering action
 * @param context SSR context
 * @param body HTML template
 */
export declare function uiCreateServerApp<T>(app: App<T>, request: Request, router?: Router | undefined, options?: NitroAppOptions, action?: (app: App<T>) => Promise<void> | void, context?: SSRContext, body?: string): Promise<{
    appHtml: string;
    teleportsHtml: string;
    context: SSRContext;
    headers: Headers | undefined;
    lang: string;
    title: string;
    meta: string;
    scriptsJson: string;
    body: string;
}>;

/**
 * Create router for SSR or client runtime.
 * @param routes Route list
 * @param options Router options
 */
export declare function uiCreateSsrRouter(routes: RouteRecordRaw[], options?: NitroAppRouterOptions): Router;

/** Generate global unique element IDs using Vue useId if available. */
export declare function uiId(): void;

/** Initialize server-side storage via injection using NITRO_APP_STORAGE. */
export declare function uiServerStorage(): void;

/**
 * Composable to get request headers.
 * @param name Header name
 */
export declare function useHeaders(name: string): string | undefined;

export declare function useHeaders(): Headers | undefined;

export { }