@analogjs/router 2.4.0-beta.9 → 3.0.0-alpha.10

package/types/server/actions/src/define-server-route.d.ts

@@ -0,0 +1,68 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { H3Event } from 'nitro/h3';
+export type DefineServerRouteResult = Response | unknown;
+export interface ServerRouteHandler<TQuery = unknown, TBody = unknown, TResult = unknown> {
+    (event: H3Event): Promise<Response>;
+    readonly _types: {
+        readonly query: TQuery;
+        readonly body: TBody;
+        readonly result: TResult;
+    };
+}
+export type InferRouteQuery<T> = T extends ServerRouteHandler<infer Q, any, any> ? Q : never;
+export type InferRouteBody<T> = T extends ServerRouteHandler<any, infer B, any> ? B : never;
+export type InferRouteResult<T> = T extends ServerRouteHandler<any, any, infer R> ? Exclude<R, Response> : never;
+type OptionalSchema = StandardSchemaV1 | undefined;
+type InferSchema<TSchema extends OptionalSchema, TFallback = unknown> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+type ResolveDataSchema<TInput extends OptionalSchema, TQuery extends OptionalSchema, TBody extends OptionalSchema> = TInput extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInput> : TQuery extends StandardSchemaV1 ? TBody extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TQuery> | StandardSchemaV1.InferOutput<TBody> : StandardSchemaV1.InferOutput<TQuery> : TBody extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TBody> : unknown;
+export interface DefineServerRouteContext<TInput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined> {
+    data: ResolveDataSchema<TInput, TQuery, TBody>;
+    query: InferSchema<TQuery, undefined>;
+    body: InferSchema<TBody, undefined>;
+    params: InferSchema<TParams, H3Event['context']['params']>;
+    event: H3Event;
+}
+export interface DefineServerRouteOptions<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined, TResult extends DefineServerRouteResult = DefineServerRouteResult> {
+    input?: TInput;
+    query?: TQuery;
+    body?: TBody;
+    params?: TParams;
+    output?: TOutput;
+    handler: (context: DefineServerRouteContext<TInput, TQuery, TBody, TParams>) => Promise<TResult> | TResult;
+}
+/**
+ * Creates an h3-compatible event handler with Standard Schema validation.
+ *
+ * - `input` schema validates the request body (POST/PUT/PATCH) or query
+ *   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.
+ * - `output` schema validates the response in development only (stripped
+ *   in production for zero overhead). Logs a warning on mismatch.
+ * - Plain return values are serialized with `json(...)`; raw `Response`
+ *   objects are returned unchanged.
+ *
+ * @example
+ * ```typescript
+ * import { defineServerRoute } from '@analogjs/router/server/actions';
+ * import * as v from 'valibot';
+ *
+ * const Input = v.object({
+ *   name: v.pipe(v.string(), v.minLength(1)),
+ *   email: v.pipe(v.string(), v.email()),
+ * });
+ * const Output = v.object({
+ *   id: v.string(),
+ *   name: v.string(),
+ * });
+ *
+ * export default defineServerRoute({
+ *   input: Input,
+ *   output: Output,
+ *   handler: async ({ data }) => {
+ *     const user = await db.users.create(data);
+ *     return user;
+ *   },
+ * });
+ * ```
+ */
+export declare function defineServerRoute<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TQuery extends StandardSchemaV1 | undefined = undefined, TBody extends StandardSchemaV1 | undefined = undefined, TParams extends StandardSchemaV1 | undefined = undefined, TResult extends DefineServerRouteResult = DefineServerRouteResult>(options: DefineServerRouteOptions<TInput, TOutput, TQuery, TBody, TParams, TResult>): ServerRouteHandler<InferSchema<TQuery, undefined>, InferSchema<TBody, undefined>, TResult>;
+export {};

package/types/server/actions/src/index.d.ts

@@ -0,0 +1,9 @@
+export type { PageServerAction } from './actions';
+export { json, redirect, fail } from './actions';
+export { defineAction } from './define-action';
+export type { DefineActionContext, DefineActionOptions } from './define-action';
+export { defineServerRoute } from './define-server-route';
+export type { DefineServerRouteContext, DefineServerRouteOptions, DefineServerRouteResult, ServerRouteHandler, InferRouteQuery, InferRouteBody, InferRouteResult, } from './define-server-route';
+export { definePageLoad } from './define-page-load';
+export type { PageLoadContext, DefinePageLoadOptions, } from './define-page-load';
+export { validateWithSchema } from './validate';

package/types/server/actions/src/parse-request-data.d.ts

@@ -0,0 +1,9 @@
+type RequestEntryValue = string | File;
+type ParsedRequestValue = RequestEntryValue | RequestEntryValue[];
+export declare function parseSearchParams(searchParams: URLSearchParams): Record<string, ParsedRequestValue>;
+export declare function parseFormData(formData: FormData): Record<string, ParsedRequestValue>;
+export declare function parseRequestData(event: {
+    method: string;
+    headers: Headers;
+}): Promise<unknown>;
+export {};

package/types/server/actions/src/validate.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+/**
+ * Validates unknown input against a Standard Schema.
+ *
+ * Handles both sync and async `validate` implementations — the Standard
+ * Schema spec allows either return shape.
+ */
+export declare function validateWithSchema<T extends StandardSchemaV1>(schema: T, data: unknown): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>>;

package/types/server/src/index.d.ts

@@ -0,0 +1,4 @@
+export { provideServerContext } from './provide-server-context';
+export { injectStaticProps, injectStaticOutputs } from './tokens';
+export { serverComponentRequest, renderServerComponent, } from './server-component-render';
+export { render } from './render';

package/types/server/src/provide-server-context.d.ts

@@ -0,0 +1,11 @@
+import { StaticProvider } from '@angular/core';
+import { ServerInternalFetch, ServerRequest, ServerResponse } from '@analogjs/router/tokens';
+export declare function provideServerContext({ req, res, fetch, }: {
+    req: ServerRequest;
+    res: ServerResponse;
+    fetch?: ServerInternalFetch;
+}): StaticProvider[];
+export declare function getBaseUrl(req: ServerRequest): string;
+export declare function getRequestProtocol(req: ServerRequest, opts?: {
+    xForwardedProto?: boolean;
+}): string;

package/types/server/src/render.d.ts

@@ -0,0 +1,12 @@
+import { ApplicationConfig, Provider, Type } from '@angular/core';
+import type { ServerContext } from '@analogjs/router/tokens';
+/**
+ * Returns a function that accepts the navigation URL,
+ * the root HTML, and server context.
+ *
+ * @param rootComponent
+ * @param config
+ * @param platformProviders
+ * @returns Promise<string | Reponse>
+ */
+export declare function render(rootComponent: Type<unknown>, config: ApplicationConfig, platformProviders?: Provider[]): (url: string, document: string, serverContext: ServerContext) => Promise<string | Response>;

package/types/server/src/server-component-render.d.ts

@@ -0,0 +1,4 @@
+import { ApplicationConfig } from '@angular/core';
+import { ServerContext } from '@analogjs/router/tokens';
+export declare function serverComponentRequest(serverContext: ServerContext): string | undefined;
+export declare function renderServerComponent(url: string, serverContext: ServerContext, config?: ApplicationConfig): Promise<Response>;

package/types/server/src/tokens.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, Provider } from '@angular/core';
+export declare const STATIC_PROPS: InjectionToken<Record<string, any>>;
+export declare function provideStaticProps<T = Record<string, any>>(props: T): Provider;
+export declare function injectStaticProps(): Record<string, any>;
+export declare function injectStaticOutputs<T>(): {
+    set(data: T): void;
+};

package/types/src/index.d.ts

@@ -0,0 +1,16 @@
+export type { RouteExport } from './lib/models';
+export type { Files } from './lib/routes';
+export { routes, createRoutes } from './lib/routes';
+export { defineRouteMeta, injectActivatedRoute, injectRouter, } from './lib/define-route';
+export { RouteMeta } from './lib/models';
+export { provideFileRouter, withExtraRoutes } from './lib/provide-file-router';
+export { MetaTag } from './lib/meta-tags';
+export { PageServerLoad, LoadResult, LoadDataResult } from './lib/route-types';
+export { injectLoad, injectLoadData } from './lib/inject-load';
+export { getLoadResolver } from './lib/get-load-resolver';
+export { requestContextInterceptor } from './lib/request-context';
+export { injectRouteEndpointURL } from './lib/inject-route-endpoint-url';
+export { FormAction } from './lib/form-action.directive';
+export { injectDebugRoutes } from './lib/debug/routes';
+export { withDebugRoutes } from './lib/debug';
+export { ServerOnly } from './lib/server.component';

package/types/src/lib/cache-key.d.ts

@@ -0,0 +1,3 @@
+import { HttpRequest } from '@angular/common/http';
+import { StateKey } from '@angular/core';
+export declare function makeCacheKey(request: HttpRequest<any>, mappedRequestUrl: string): StateKey<unknown>;

package/types/src/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ENDPOINT_EXTENSION = ".server.ts";
+export declare const APP_DIR = "src/app";

package/types/src/lib/cookie-interceptor.d.ts

@@ -0,0 +1,4 @@
+import { HttpHandlerFn, HttpRequest, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ServerRequest } from '@analogjs/router/tokens';
+export declare function cookieInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn, location?: object, serverRequest?: ServerRequest | null): Observable<HttpEvent<unknown>>;

package/types/src/lib/debug/debug.page.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import { DebugRoute } from './routes';
+import * as i0 from "@angular/core";
+type CollectedRoute = {
+    path: string;
+    filename: string;
+    file: string;
+    isLayout: boolean;
+};
+export default class DebugRoutesComponent implements OnInit {
+    collectedRoutes: CollectedRoute[];
+    debugRoutes: (import('@angular/router').Route & DebugRoute)[];
+    ngOnInit(): void;
+    traverseRoutes(routes: DebugRoute[], parent?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugRoutesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DebugRoutesComponent, "analogjs-debug-routes-page", never, {}, {}, never, never, true, never>;
+}
+export {};

package/types/src/lib/debug/index.d.ts

@@ -0,0 +1,10 @@
+import { EnvironmentProviders, Provider } from '@angular/core';
+/**
+ * Provides routes that provide additional
+ * pages for displaying and debugging
+ * routes.
+ */
+export declare function withDebugRoutes(): {
+    ɵkind: number;
+    ɵproviders: (Provider | EnvironmentProviders)[];
+};

package/types/src/lib/debug/routes.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { Route } from '@angular/router';
+export declare const DEBUG_ROUTES: InjectionToken<(Route & DebugRoute)[]>;
+export type DebugRoute = {
+    path: string;
+    filename: string;
+    isLayout: boolean;
+    children?: DebugRoute[];
+};
+export declare function injectDebugRoutes(): (Route & DebugRoute)[];

package/types/src/lib/define-route.d.ts

@@ -0,0 +1,46 @@
+import { Route as NgRoute, Router } from '@angular/router';
+import { ActivatedRoute } from '@angular/router';
+type RouteOmitted = 'component' | 'loadComponent' | 'loadChildren' | 'path' | 'pathMatch';
+type RestrictedRoute = Omit<NgRoute, RouteOmitted>;
+/**
+ * @deprecated Use `RouteMeta` type instead.
+ * For more info see: https://github.com/analogjs/analog/issues/223
+ *
+ * Defines additional route config metadata. This
+ * object is merged into the route config with
+ * the predefined file-based route.
+ *
+ * @usageNotes
+ *
+ * ```
+ * import { Component } from '@angular/core';
+ * import { defineRouteMeta } from '@analogjs/router';
+ *
+ *  export const routeMeta = defineRouteMeta({
+ *    title: 'Welcome'
+ *  });
+ *
+ * @Component({
+ *   template: `Home`,
+ *   standalone: true,
+ * })
+ * export default class HomeComponent {}
+ * ```
+ *
+ * @param route
+ * @returns
+ */
+export declare const defineRouteMeta: (route: RestrictedRoute) => RestrictedRoute;
+/**
+ * Returns the instance of Angular Router
+ *
+ * @returns The router
+ */
+export declare const injectRouter: () => Router;
+/**
+ * Returns the instance of the Activate Route for the component
+ *
+ * @returns The activated route
+ */
+export declare const injectActivatedRoute: () => ActivatedRoute;
+export {};

package/types/src/lib/endpoints.d.ts

@@ -0,0 +1,5 @@
+export declare const ANALOG_META_KEY: unique symbol;
+/**
+ * This variable reference is replaced with a glob of all route endpoints.
+ */
+export declare const ANALOG_PAGE_ENDPOINTS: any;

package/types/src/lib/form-action.directive.d.ts

@@ -0,0 +1,25 @@
+import { type InputSignal, type OutputEmitterRef, type WritableSignal } from '@angular/core';
+import * as i0 from "@angular/core";
+export type FormActionState = 'submitting' | 'error' | 'redirect' | 'success' | 'navigate';
+export declare class FormAction {
+    action: InputSignal<string>;
+    onSuccess: OutputEmitterRef<unknown>;
+    onError: OutputEmitterRef<unknown>;
+    state: OutputEmitterRef<FormActionState>;
+    private router;
+    private route;
+    protected currentState: WritableSignal<FormActionState | 'idle'>;
+    /** Cached during construction (injection context) so inject() works. */
+    private _endpointUrl;
+    submitted($event: any): void;
+    private _handleGet;
+    private _handlePost;
+    private _getExplicitAction;
+    private _getGetPath;
+    private _getPostPath;
+    private _emitState;
+    private _navigateTo;
+    private _isJSON;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormAction, "form[action],form[method]", never, { "action": { "alias": "action"; "required": false; "isSignal": true; }; }, { "onSuccess": "onSuccess"; "onError": "onError"; "state": "state"; }, never, never, true, never>;
+}

package/types/src/lib/get-load-resolver.d.ts

@@ -0,0 +1,8 @@
+import { ActivatedRouteSnapshot } from '@angular/router';
+/**
+ * Get server load resolver data for the route
+ *
+ * @param route Provides the route to get server load resolver
+ * @returns Returns server load resolver data for the route
+ */
+export declare function getLoadResolver<T>(route: ActivatedRouteSnapshot): Promise<T>;

package/types/src/lib/inject-load.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { LoadDataResult, PageServerLoad } from './route-types';
+export declare function injectLoad<T extends (pageServerLoad: PageServerLoad) => Promise<any>>(options?: {
+    injector?: Injector;
+}): Observable<Awaited<ReturnType<T>>>;
+export declare function injectLoadData<T extends (pageServerLoad: PageServerLoad) => Promise<any>>(options?: {
+    injector?: Injector;
+}): Observable<LoadDataResult<T>>;

package/types/src/lib/inject-route-endpoint-url.d.ts

@@ -0,0 +1,2 @@
+import type { ActivatedRouteSnapshot } from '@angular/router';
+export declare function injectRouteEndpointURL(route: ActivatedRouteSnapshot): URL;

package/types/src/lib/markdown-helpers.d.ts

@@ -0,0 +1,2 @@
+import { RouteExport } from './models';
+export declare function toMarkdownModule(markdownFileFactory: () => Promise<string>): () => Promise<RouteExport>;

package/types/src/lib/meta-tags.d.ts

@@ -0,0 +1,33 @@
+export declare const ROUTE_META_TAGS_KEY: unique symbol;
+declare const CHARSET_KEY = "charset";
+declare const HTTP_EQUIV_KEY = "httpEquiv";
+declare const NAME_KEY = "name";
+declare const PROPERTY_KEY = "property";
+declare const CONTENT_KEY = "content";
+declare const ITEMPROP_KEY = "itemprop";
+export type MetaTag = (CharsetMetaTag & ExcludeRestMetaTagKeys<typeof CHARSET_KEY>) | (HttpEquivMetaTag & ExcludeRestMetaTagKeys<typeof HTTP_EQUIV_KEY>) | (NameMetaTag & ExcludeRestMetaTagKeys<typeof NAME_KEY>) | (PropertyMetaTag & ExcludeRestMetaTagKeys<typeof PROPERTY_KEY>) | (ItempropMetaTag & ExcludeRestMetaTagKeys<typeof ITEMPROP_KEY>);
+type CharsetMetaTag = {
+    [CHARSET_KEY]: string;
+};
+type HttpEquivMetaTag = {
+    [HTTP_EQUIV_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type NameMetaTag = {
+    [NAME_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type PropertyMetaTag = {
+    [PROPERTY_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type ItempropMetaTag = {
+    [ITEMPROP_KEY]: string;
+    [CONTENT_KEY]: string;
+};
+type MetaTagKey = typeof CHARSET_KEY | typeof HTTP_EQUIV_KEY | typeof NAME_KEY | typeof PROPERTY_KEY | typeof ITEMPROP_KEY;
+type ExcludeRestMetaTagKeys<Key extends MetaTagKey> = {
+    [K in Exclude<MetaTagKey, Key>]?: never;
+};
+export declare function updateMetaTagsOnRouteChange(): void;
+export {};

package/types/src/lib/models.d.ts

@@ -0,0 +1,29 @@
+import { Type } from '@angular/core';
+import { CanActivateChildFn, CanActivateFn, CanDeactivateFn, CanMatchFn, DeprecatedGuard, ResolveFn, Route } from '@angular/router';
+import { defineRouteMeta } from './define-route';
+import { MetaTag } from './meta-tags';
+type OmittedRouteProps = 'path' | 'matcher' | 'component' | 'loadComponent' | 'children' | 'loadChildren' | 'canLoad' | 'outlet';
+export type RouteConfig = Omit<Route, OmittedRouteProps>;
+export interface DefaultRouteMeta extends Omit<Route, OmittedRouteProps | keyof RedirectRouteMeta> {
+    canActivate?: CanActivateFn[] | DeprecatedGuard[];
+    canActivateChild?: CanActivateChildFn[];
+    canDeactivate?: CanDeactivateFn<unknown>[];
+    canMatch?: CanMatchFn[];
+    resolve?: {
+        [key: string | symbol]: ResolveFn<unknown>;
+    };
+    title?: string | ResolveFn<string>;
+    meta?: MetaTag[] | ResolveFn<MetaTag[]>;
+}
+export interface RedirectRouteMeta {
+    redirectTo: string;
+    pathMatch?: Route['pathMatch'];
+}
+export type RouteMeta = (DefaultRouteMeta & {
+    redirectTo?: never;
+}) | RedirectRouteMeta;
+export type RouteExport = {
+    default: Type<unknown>;
+    routeMeta?: RouteMeta | ReturnType<typeof defineRouteMeta>;
+};
+export {};

package/types/src/lib/provide-file-router.d.ts

@@ -0,0 +1,18 @@
+import { EnvironmentProviders } from '@angular/core';
+import { RouterFeatures, Routes } from '@angular/router';
+/**
+ * Sets up providers for the Angular router, and registers
+ * file-based routes. Additional features can be provided
+ * to further configure the behavior of the router.
+ *
+ * @param features
+ * @returns Providers and features to configure the router with routes
+ */
+export declare function provideFileRouter(...features: RouterFeatures[]): EnvironmentProviders;
+/**
+ * Provides extra custom routes in addition to the routes
+ * discovered from the filesystem-based routing. These routes are
+ * inserted before the filesystem-based routes, and take priority in
+ * route matching.
+ */
+export declare function withExtraRoutes(routes: Routes): RouterFeatures;

package/types/src/lib/request-context.d.ts

@@ -0,0 +1,13 @@
+import { HttpEvent, HttpHandlerFn, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+/**
+ * Interceptor that is server-aware when making HttpClient requests.
+ * Server-side requests use the full URL
+ * Prerendering uses the internal Nitro $fetch function, along with state transfer
+ * Client-side requests use the window.location.origin
+ *
+ * @param req HttpRequest<unknown>
+ * @param next HttpHandlerFn
+ * @returns
+ */
+export declare function requestContextInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;

package/types/src/lib/route-config.d.ts

@@ -0,0 +1,2 @@
+import { RouteConfig, RouteMeta } from './models';
+export declare function toRouteConfig(routeMeta: RouteMeta | undefined): RouteConfig;

package/types/src/lib/route-types.d.ts

@@ -0,0 +1,12 @@
+import type { H3Event, H3EventContext } from 'nitro/h3';
+import type { $Fetch } from 'nitro/types';
+export type NodeContext = NonNullable<H3Event['node']>;
+export type PageServerLoad = {
+    params: H3EventContext['params'];
+    req: NodeContext['req'];
+    res: NonNullable<NodeContext['res']>;
+    fetch: $Fetch;
+    event: H3Event;
+};
+export type LoadResult<A extends (pageServerLoad: PageServerLoad) => Promise<any>> = Awaited<ReturnType<A>>;
+export type LoadDataResult<A extends (pageServerLoad: PageServerLoad) => Promise<any>> = Exclude<LoadResult<A>, Response>;

package/types/src/lib/routes.d.ts

@@ -0,0 +1,19 @@
+import type { Route } from '@angular/router';
+import type { RouteExport } from './models';
+/**
+ * This variable reference is replaced with a glob of all page routes.
+ */
+export declare const ANALOG_ROUTE_FILES: {};
+/**
+ * This variable reference is replaced with a glob of all content routes.
+ */
+export declare const ANALOG_CONTENT_ROUTE_FILES: {};
+export type Files = Record<string, () => Promise<RouteExport | string>>;
+/**
+ * A function used to parse list of files and create configuration of routes.
+ *
+ * @param files
+ * @returns Array of routes
+ */
+export declare function createRoutes(files: Files, debug?: boolean): Route[];
+export declare const routes: Route[];

package/types/src/lib/server.component.d.ts

@@ -0,0 +1,33 @@
+import { InputSignal, OutputEmitterRef, WritableSignal } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+type ServerProps = Record<string, any>;
+type ServerOutputs = Record<string, any>;
+/**
+ * @description
+ * Component that defines the bridge between the client and server-only
+ * components. The component passes the component ID and props to the server
+ * and retrieves the rendered HTML and outputs from the server-only component.
+ *
+ * Status: experimental
+ */
+export declare class ServerOnly {
+    component: InputSignal<string>;
+    props: InputSignal<ServerProps | undefined>;
+    outputs: OutputEmitterRef<ServerOutputs>;
+    private http;
+    private sanitizer;
+    protected content: WritableSignal<SafeHtml>;
+    private route;
+    private baseURL;
+    private transferState;
+    constructor();
+    updateContent(content: {
+        html: string;
+        outputs: ServerOutputs;
+    }): void;
+    getComponentUrl(componentId: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerOnly, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServerOnly, "server-only,ServerOnly,Server", never, { "component": { "alias": "component"; "required": true; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+export {};

package/types/tanstack-query/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ANALOG_QUERY_STATE_KEY, provideAnalogQuery, } from './provide-analog-query.js';
+export { serverQueryOptions, serverMutationOptions, serverInfiniteQueryOptions, } from './server-query.js';

package/types/tanstack-query/src/provide-analog-query.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentProviders, StateKey } from '@angular/core';
+import type { DehydratedState } from '@tanstack/angular-query-experimental';
+export declare const ANALOG_QUERY_STATE_KEY: StateKey<DehydratedState>;
+export declare function provideAnalogQuery(): EnvironmentProviders;

package/types/tanstack-query/src/provide-server-analog-query.d.ts

@@ -0,0 +1,2 @@
+import type { EnvironmentProviders } from '@angular/core';
+export declare function provideServerAnalogQuery(): EnvironmentProviders;

package/types/tanstack-query/src/server-query.d.ts

@@ -0,0 +1,16 @@
+import type { HttpClient } from '@angular/common/http';
+import type { CreateQueryOptions, CreateMutationOptions, CreateInfiniteQueryOptions, DefaultError, InfiniteData, QueryKey } from '@tanstack/angular-query-experimental';
+import type { ServerRouteHandler, InferRouteQuery, InferRouteBody, InferRouteResult } from '@analogjs/router/server/actions';
+export declare function serverQueryOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TData = InferRouteResult<TRoute>, TQueryKey extends QueryKey = QueryKey>(http: HttpClient, url: string, options: {
+    queryKey: TQueryKey;
+    query?: InferRouteQuery<TRoute>;
+} & Omit<CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>, 'queryKey' | 'queryFn'>): CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>;
+export declare function serverMutationOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TOnMutateResult = unknown>(http: HttpClient, url: string, options?: Omit<CreateMutationOptions<InferRouteResult<TRoute>, TError, InferRouteBody<TRoute>, TOnMutateResult>, 'mutationFn'>): CreateMutationOptions<InferRouteResult<TRoute>, TError, InferRouteBody<TRoute>, TOnMutateResult>;
+export declare function serverInfiniteQueryOptions<TRoute extends ServerRouteHandler<any, any, any>, TError = DefaultError, TData = InfiniteData<InferRouteResult<TRoute>>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(http: HttpClient, url: string, options: {
+    queryKey: TQueryKey;
+    query: (context: {
+        pageParam: TPageParam;
+    }) => InferRouteQuery<TRoute>;
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: InferRouteResult<TRoute>, allPages: InferRouteResult<TRoute>[]) => TPageParam | undefined | null;
+} & Omit<CreateInfiniteQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'>): CreateInfiniteQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey, TPageParam>;

package/types/tokens/src/index.d.ts

@@ -0,0 +1,23 @@
+import { InjectionToken } from '@angular/core';
+import type { $Fetch } from 'nitro/types';
+import type { IncomingMessage, ServerResponse as NodeServerResponse } from 'node:http';
+export type ServerRequest = IncomingMessage & {
+    originalUrl: string;
+};
+export type ServerResponse = NodeServerResponse;
+export type ServerInternalFetch = $Fetch;
+export type ServerContext = {
+    req: ServerRequest;
+    res: ServerResponse;
+    fetch?: ServerInternalFetch;
+};
+export declare const REQUEST: InjectionToken<ServerRequest>;
+export declare const RESPONSE: InjectionToken<ServerResponse>;
+export declare const BASE_URL: InjectionToken<string>;
+export declare const INTERNAL_FETCH: InjectionToken<ServerInternalFetch>;
+export declare const API_PREFIX: InjectionToken<string>;
+export declare function injectRequest(): ServerRequest | null;
+export declare function injectResponse(): ServerResponse | null;
+export declare function injectBaseURL(): string | null;
+export declare function injectInternalServerFetch(): ServerInternalFetch | null;
+export declare function injectAPIPrefix(): string;