@supacloud/app 0.2.0 → 0.5.0

package/dist/context.d.ts

@@ -17,3 +17,44 @@ export declare const JOB_CONTEXT: InjectionToken<unknown>;
  * passed to `createApplication({ deps: { dbClient } })`.
  */
 export declare const DB_CLIENT: InjectionToken<unknown>;
+/**
+ * Built-in multi-provider token for application startup lifecycle hooks.
+ * Modeled after Angular's APP_INITIALIZER.
+ * Initializer providers can return void or a Promise<void>; the application startup sequence
+ * executes all registered initializers before accepting traffic.
+ */
+export declare const APP_INITIALIZER: InjectionToken<() => void | Promise<void>>;
+/**
+ * Built-in multi-provider token for environment initialization hooks.
+ * Modeled directly after Angular 14+ ENVIRONMENT_INITIALIZER.
+ */
+export declare const ENVIRONMENT_INITIALIZER: InjectionToken<() => void | Promise<void>>;
+/**
+ * Lifecycle interface for services that need to perform teardown logic when the application shuts down.
+ * Modeled after Angular's OnDestroy.
+ */
+export interface OnDestroy {
+    onDestroy(): void | Promise<void>;
+}
+/**
+ * Mechanism to register teardown callbacks for an active context or service.
+ * Modeled directly after Angular's DestroyRef.
+ */
+export interface DestroyRef {
+    readonly signal?: AbortSignal;
+    onDestroy(callback: () => void | Promise<void>): () => void;
+}
+/**
+ * Built-in token for registering teardown callbacks.
+ * Modeled after Angular's DestroyRef.
+ */
+export declare const DESTROY_REF: InjectionToken<DestroyRef>;
+/**
+ * Creates a default DestroyRef instance for tracking teardown hooks.
+ */
+export declare function createDestroyRef(): DestroyRef & {
+    readonly destroyed: boolean;
+    readonly signal: AbortSignal;
+    destroy(): Promise<void>;
+    _teardowns: Array<() => void | Promise<void>>;
+};

package/dist/decorators.d.ts

@@ -1,4 +1,5 @@
 import type { Provider, Token, Type } from "./provider";
+import type { EnvironmentProviders } from "./provider";
 import type { Scope } from "./scope";
 /**
  * Decorator metadata keys. Metadata is attached as static properties on the
@@ -12,25 +13,53 @@ export declare const QUERY_METADATA = "supacloud:query";
 export declare const CONTROLLER_METADATA = "supacloud:controller";
 export declare const ROUTES_METADATA = "supacloud:routes";
 export declare const INJECT_PARAMS_METADATA = "supacloud:inject-params";
+export declare const OPTIONAL_PARAMS_METADATA = "supacloud:optional-params";
+export declare const SELF_PARAMS_METADATA = "supacloud:self-params";
+export declare const SKIP_SELF_PARAMS_METADATA = "supacloud:skip-self-params";
+export declare const HOST_PARAMS_METADATA = "supacloud:host-params";
+export declare const GUARDS_METADATA = "supacloud:guards";
+export declare const CAN_DEACTIVATE_METADATA = "supacloud:guards:can-deactivate";
+export declare const RESOLVE_METADATA = "supacloud:resolvers";
+export declare const TITLE_METADATA = "supacloud:route:title";
+export declare const DATA_METADATA = "supacloud:route:data";
+export declare const ROUTE_PARAMS_METADATA = "supacloud:route-params";
+export interface RouteParamBinding {
+    index: number;
+    type: "param" | "query" | "body" | "headers";
+    name?: string;
+    transform?: "number" | "boolean" | "string";
+    default?: unknown;
+}
+export interface ParamOptions {
+    name?: string;
+    transform?: "number" | "boolean" | "string";
+    default?: unknown;
+}
 export interface InjectableOptions {
     scope?: Scope;
+    /** Automatically provide this service in root scope without manual module declaration (Angular-style). */
+    providedIn?: "root";
     /** Explicit constructor dependency tokens, in parameter order. */
     deps?: Token[];
 }
 export interface InjectableMeta {
     scope: Scope;
+    providedIn?: "root";
     deps: Token[];
 }
 export interface ModuleOptions {
     name: string;
+    /** Tags for architectural boundary governance (e.g. ['scope:case', 'type:feature']). */
+    tags?: string[];
     imports?: Array<Type<unknown>>;
-    providers?: Provider[];
+    providers?: Array<Provider | EnvironmentProviders>;
     controllers?: Array<Type<unknown>>;
     commands?: Array<Type<unknown>>;
     queries?: Array<Type<unknown>>;
     exports?: Token[];
 }
-export interface ModuleMeta extends Required<Omit<ModuleOptions, "exports">> {
+export interface ModuleMeta extends Required<Omit<ModuleOptions, "exports" | "tags">> {
+    tags?: string[];
     exports: Token[];
 }
 export interface CommandOptions {
@@ -43,10 +72,13 @@ export interface CommandOptions {
     audit?: string;
     /** Idempotency strategy, e.g. "required". */
     idempotency?: "required" | "none";
+    /** Automatically discover and register without manual module declaration. */
+    standalone?: boolean;
 }
 export type CommandMeta = Omit<CommandOptions, "transaction" | "idempotency"> & {
     transaction: "required" | "none";
     idempotency: "required" | "none";
+    standalone?: boolean;
 };
 export interface QueryOptions {
     name: string;
@@ -54,8 +86,17 @@ export interface QueryOptions {
 export type QueryMeta = QueryOptions;
 export interface ControllerMeta {
     path: string;
+    standalone?: boolean;
+}
+export interface ControllerOptions {
+    path?: string;
+    standalone?: boolean;
 }
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type CanActivateFn<TContext = any> = (ctx: TContext) => boolean | Promise<boolean> | any;
+export type CanMatchFn<TContext = any> = (ctx: TContext) => boolean | Promise<boolean> | any;
+export type CanDeactivateFn<T = any, TContext = any> = (component: T, ctx: TContext) => boolean | Promise<boolean> | any;
+export type ResolveFn<T = any, TContext = any> = (ctx: TContext) => T | Promise<T>;
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
 export interface RouteOptions {
     /** TypeBox schema (or compatible) for the request body. */
     body?: unknown;
@@ -67,6 +108,22 @@ export interface RouteOptions {
     response?: unknown;
     /** Command class whose governance metadata must be enforced for this route. */
     command?: Type<unknown>;
+    /** Angular-style functional route guards executed before handler. */
+    guards?: Array<CanActivateFn | string>;
+    /** Angular-style route matching guard determining whether route can match. */
+    canMatch?: Array<CanMatchFn | string>;
+    /** Angular-style route deactivation guard executed before leaving/cleaning up route. */
+    canDeactivate?: Array<CanDeactivateFn | string>;
+    /** Angular-style route resolvers executed before handler to preload dependencies. */
+    resolvers?: Record<string, ResolveFn | string>;
+    /** Angular-style route redirect target path. */
+    redirectTo?: string;
+    /** Angular-style route path matching strategy. */
+    pathMatch?: "full" | "prefix";
+    /** Route title or label (modeled after Angular Route.title). */
+    title?: string;
+    /** Static route metadata dictionary (modeled after Angular Route.data). */
+    data?: Record<string, unknown>;
 }
 export interface RouteDefinition extends RouteOptions {
     method: HttpMethod;
@@ -83,17 +140,74 @@ export declare function getInjectableMeta(target: object): InjectableMeta | unde
  */
 export declare function Inject(token: Token): ParameterDecorator;
 export declare function getInjectParams(target: object): Record<number, Token>;
+/**
+ * Parameter decorator marking a constructor parameter as optional.
+ * Modeled after Angular's @Optional(); if unresolved, the parameter receives undefined.
+ */
+export declare function Optional(): ParameterDecorator;
+export declare function getOptionalParams(target: object): number[];
+/**
+ * Parameter decorator asserting that dependency must be provided in the current module/scope.
+ * Modeled after Angular's @Self(); fails at compile time if resolved from imported modules or fallback.
+ */
+export declare function Self(): ParameterDecorator;
+export declare function getSelfParams(target: object): number[];
+/**
+ * Parameter decorator asserting that dependency must NOT be resolved from the current module itself.
+ * Modeled after Angular's @SkipSelf(); searches parent/imported scopes.
+ */
+export declare function SkipSelf(): ParameterDecorator;
+export declare function getSkipSelfParams(target: object): number[];
+/**
+ * Parameter decorator specifying host resolution boundary.
+ * Modeled after Angular's @Host().
+ */
+export declare function Host(): ParameterDecorator;
+export declare function getHostParams(target: object): number[];
+/**
+ * Class and method decorator attaching functional route guards.
+ * Modeled after Angular Router guards.
+ */
+export declare function UseGuards(...guards: Array<CanActivateFn | string>): ClassDecorator & MethodDecorator;
+export declare function getGuards(target: object, propertyKey?: string | symbol): Array<CanActivateFn | string>;
 export declare function Module(options: ModuleOptions): ClassDecorator;
 export declare function getModuleMeta(target: object): ModuleMeta | undefined;
 export declare function Command(options: CommandOptions): ClassDecorator;
 export declare function getCommandMeta(target: object): CommandMeta | undefined;
-export declare function Query(options: QueryOptions): ClassDecorator;
+export declare function Param(nameOrOptions?: string | ParamOptions, options?: ParamOptions): ParameterDecorator;
+export declare function Body(): ParameterDecorator;
+export declare function Headers(name?: string): ParameterDecorator;
+export declare function Query(optionsOrName?: QueryOptions | ParamOptions | string, options?: ParamOptions): ClassDecorator & ParameterDecorator;
+export declare function getRouteParams(target: object, propertyKey: string | symbol): RouteParamBinding[];
 export declare function getQueryMeta(target: object): QueryMeta | undefined;
-export declare function Controller(path: string): ClassDecorator;
+export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
 export declare function getControllerMeta(target: object): ControllerMeta | undefined;
 export declare const Get: (path: string, options?: RouteOptions) => MethodDecorator;
 export declare const Post: (path: string, options?: RouteOptions) => MethodDecorator;
 export declare const Put: (path: string, options?: RouteOptions) => MethodDecorator;
 export declare const Patch: (path: string, options?: RouteOptions) => MethodDecorator;
 export declare const Delete: (path: string, options?: RouteOptions) => MethodDecorator;
+export declare const Head: (path: string, options?: RouteOptions) => MethodDecorator;
+export declare const Options: (path: string, options?: RouteOptions) => MethodDecorator;
+/**
+ * Sets a route title. Modeled after Angular Route.title.
+ */
+export declare function Title(title: string): MethodDecorator;
+/**
+ * Attaches arbitrary static metadata to a route. Modeled after Angular Route.data.
+ */
+export declare function Data(data: Record<string, unknown>): MethodDecorator;
+/**
+ * Attaches CanDeactivateFn guards to a route method. Modeled after Angular Route.canDeactivate.
+ */
+export declare function CanDeactivate(...guards: Array<CanDeactivateFn | string>): MethodDecorator;
+/**
+ * Attaches route pre-activation resolvers to a route method. Modeled after Angular Route.resolve.
+ * Resolvers run before the route handler, allowing prefetching and validation without controller boilerplate.
+ */
+export declare function Resolve(resolvers: Record<string, ResolveFn | string>): MethodDecorator;
+/**
+ * Executes a dictionary of route resolvers concurrently.
+ */
+export declare function executeResolvers<TContext = any>(resolvers: Record<string, ResolveFn | string>, ctx: TContext): Promise<Record<string, unknown>>;
 export declare function getRoutes(target: object): RouteDefinition[];

package/dist/forms.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Angular-style Reactive Forms & Validation Suite (@angular/forms).
+ * Zero-dependency, type-safe, reactive form model and validator collection.
+ */
+export type FormControlStatus = "VALID" | "INVALID" | "PENDING" | "DISABLED";
+export type ValidationErrors = Record<string, unknown>;
+export type ValidatorFn = (control: AbstractControl) => ValidationErrors | null;
+export type AsyncValidatorFn = (control: AbstractControl) => Promise<ValidationErrors | null>;
+export interface AbstractControlOptions {
+    validators?: ValidatorFn | ValidatorFn[] | null;
+    asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
+}
+/**
+ * Base class for all Angular-style form controls: FormControl, FormGroup, FormArray.
+ */
+export declare abstract class AbstractControl<TValue = any> {
+    private _value;
+    private _status;
+    private _errors;
+    private _pristine;
+    private _touched;
+    private _parent;
+    protected _validator: ValidatorFn | null;
+    protected _asyncValidator: AsyncValidatorFn | null;
+    constructor(validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get value(): TValue;
+    protected setRawValue(val: TValue): void;
+    get status(): FormControlStatus;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get disabled(): boolean;
+    get enabled(): boolean;
+    get errors(): ValidationErrors | null;
+    get pristine(): boolean;
+    get dirty(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
+    get parent(): FormGroup | FormArray | null;
+    setParent(parent: FormGroup | FormArray | null): void;
+    markAsTouched(): void;
+    markAsUntouched(): void;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    disable(): void;
+    enable(): void;
+    setErrors(errors: ValidationErrors | null): void;
+    hasError(errorCode: string, path?: string | (string | number)[]): boolean;
+    getError(errorCode: string, path?: string | (string | number)[]): unknown;
+    abstract setValue(value: any): void;
+    abstract patchValue(value: any): void;
+    abstract reset(value?: any): void;
+    get(_path: string | (string | number)[]): AbstractControl | null;
+    updateValueAndValidity(): void;
+}
+/**
+ * Tracks the value and validity status of an individual form control.
+ */
+export declare class FormControl<T = any> extends AbstractControl<T> {
+    constructor(formState?: T | {
+        value: T;
+        disabled?: boolean;
+    }, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    setValue(value: any): void;
+    patchValue(value: any): void;
+    reset(formState?: any): void;
+}
+/**
+ * Tracks the value and validity status of a group of named AbstractControl instances.
+ */
+export declare class FormGroup<TControls extends Record<string, AbstractControl> = Record<string, AbstractControl>> extends AbstractControl<{
+    [K in keyof TControls]: TControls[K]["value"];
+}> {
+    readonly controls: TControls;
+    constructor(controls: TControls, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get value(): {
+        [K in keyof TControls]: TControls[K]["value"];
+    };
+    get(path: string | (string | number)[]): AbstractControl | null;
+    addControl(name: string, control: AbstractControl): void;
+    removeControl(name: string): void;
+    setControl(name: string, control: AbstractControl): void;
+    contains(name: string): boolean;
+    setValue(value: any): void;
+    patchValue(value: any): void;
+    reset(): void;
+    updateValueAndValidity(): void;
+}
+/**
+ * Tracks the value and validity status of an array of AbstractControl instances.
+ */
+export declare class FormArray<TControl extends AbstractControl = AbstractControl> extends AbstractControl<Array<TControl["value"]>> {
+    readonly controls: TControl[];
+    constructor(controls?: TControl[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get length(): number;
+    at(index: number): TControl | null;
+    push(control: TControl): void;
+    insert(index: number, control: TControl): void;
+    removeAt(index: number): void;
+    clear(): void;
+    get value(): Array<TControl["value"]>;
+    setValue(value: any): void;
+    patchValue(value: any): void;
+    reset(): void;
+    updateValueAndValidity(): void;
+}
+/**
+ * Standard Angular-inspired Validators collection (@angular/forms).
+ */
+export declare class Validators {
+    static nullValidator(_control: AbstractControl): null;
+    static required(control: AbstractControl): ValidationErrors | null;
+    static requiredTrue(control: AbstractControl): ValidationErrors | null;
+    static min(min: number): ValidatorFn;
+    static max(max: number): ValidatorFn;
+    static minLength(minLength: number): ValidatorFn;
+    static maxLength(maxLength: number): ValidatorFn;
+    static email(control: AbstractControl): ValidationErrors | null;
+    static pattern(pattern: string | RegExp): ValidatorFn;
+    static compose(validators: (ValidatorFn | null | undefined)[] | null): ValidatorFn | null;
+    static composeAsync(validators: (AsyncValidatorFn | null | undefined)[] | null): AsyncValidatorFn | null;
+}

package/dist/forward_ref.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Allows referring to references which are not yet defined.
+ * Modeled directly after Angular's `forwardRef`.
+ *
+ * Example:
+ * ```ts
+ * @Inject(forwardRef(() => DependentService))
+ * ```
+ */
+export interface ForwardRefFn<T = unknown> {
+    (): T;
+    __forward_ref__?: typeof forwardRef;
+}
+export declare function forwardRef<T>(fn: () => T): ForwardRefFn<T>;
+export declare function resolveForwardRef<T>(type: T): T;
+export declare function isForwardRef(fn: unknown): fn is ForwardRefFn;

package/dist/http_client.d.ts

@@ -0,0 +1,53 @@
+import { HttpContext } from "./http_context";
+import { HttpHeaders } from "./http_headers";
+import { HttpParams } from "./http_params";
+import { type HttpInterceptorFn } from "./interceptor";
+import { InjectionToken } from "./token";
+import { type EnvironmentProviders, type Provider } from "./provider";
+export interface HttpClientConfig {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+export declare const HTTP_CLIENT_CONFIG: InjectionToken<HttpClientConfig>;
+export declare const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptorFn[]>;
+export declare class HttpErrorResponse extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string | null;
+    readonly error: unknown;
+    constructor(init: {
+        error?: unknown;
+        status?: number;
+        statusText?: string;
+        url?: string;
+    });
+}
+export interface HttpRequestOptions {
+    headers?: HttpHeaders | Record<string, string | string[]>;
+    params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
+    body?: unknown;
+    context?: HttpContext;
+    observe?: "body" | "response";
+    responseType?: "json" | "text" | "blob";
+    signal?: AbortSignal;
+}
+export type HttpClientFeatureKind = "Fetch" | "Interceptors" | "ParentRequests";
+export interface HttpClientFeature {
+    kind: HttpClientFeatureKind;
+    providers: Provider[];
+}
+export declare function withFetch(customFetch?: typeof fetch): HttpClientFeature;
+export declare function withInterceptors(...interceptors: (HttpInterceptorFn | HttpInterceptorFn[])[]): HttpClientFeature;
+export declare function withRequestsMadeViaParent(): HttpClientFeature;
+export declare function provideHttpClient(...features: HttpClientFeature[]): EnvironmentProviders;
+export declare class HttpClient {
+    private config;
+    private interceptors;
+    constructor(config?: HttpClientConfig, interceptors?: HttpInterceptorFn[]);
+    get<T = unknown>(url: string, options?: HttpRequestOptions): Promise<T>;
+    post<T = unknown>(url: string, body?: unknown, options?: HttpRequestOptions): Promise<T>;
+    put<T = unknown>(url: string, body?: unknown, options?: HttpRequestOptions): Promise<T>;
+    delete<T = unknown>(url: string, options?: HttpRequestOptions): Promise<T>;
+    patch<T = unknown>(url: string, body?: unknown, options?: HttpRequestOptions): Promise<T>;
+    request<T = unknown>(method: string, url: string, options?: HttpRequestOptions): Promise<T>;
+}

package/dist/http_context.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Angular-inspired typed HTTP context token and context bag.
+ * Modeled after Angular's @angular/common/http HttpContext and HttpContextToken API.
+ */
+export declare class HttpContextToken<T> {
+    readonly defaultValue: () => T;
+    constructor(defaultValue: () => T);
+}
+export declare class HttpContext {
+    private readonly map;
+    set<T>(token: HttpContextToken<T>, value: T): this;
+    get<T>(token: HttpContextToken<T>): T;
+    delete(token: HttpContextToken<unknown>): this;
+    has(token: HttpContextToken<unknown>): boolean;
+    keys(): IterableIterator<HttpContextToken<unknown>>;
+}

package/dist/http_headers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Angular-inspired immutable HttpHeaders builder.
+ * Modeled after Angular's @angular/common/http HttpHeaders API.
+ * Header names are treated case-insensitively.
+ */
+export declare class HttpHeaders {
+    private readonly headersMap;
+    private readonly originalNames;
+    constructor(headers?: Record<string, string | string[]> | HttpHeaders);
+    private clone;
+    has(name: string): boolean;
+    get(name: string): string | null;
+    getAll(name: string): string[] | null;
+    keys(): string[];
+    set(name: string, value: string | string[]): HttpHeaders;
+    append(name: string, value: string | string[]): HttpHeaders;
+    delete(name: string): HttpHeaders;
+    toObject(): Record<string, string>;
+}

package/dist/http_params.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Angular-inspired immutable HttpParams query parameter builder.
+ * Modeled after Angular's @angular/common/http HttpParams API.
+ */
+export interface HttpParamsOptions {
+    /** String in standard query string format (e.g. 'a=1&b=2') */
+    fromString?: string;
+    /** Object mapping parameter names to primitive values or arrays */
+    fromObject?: Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
+}
+export declare class HttpParams {
+    private readonly map;
+    constructor(options?: HttpParamsOptions);
+    private clone;
+    has(param: string): boolean;
+    get(param: string): string | null;
+    getAll(param: string): string[] | null;
+    keys(): string[];
+    set(param: string, value: string | number | boolean): HttpParams;
+    append(param: string, value: string | number | boolean): HttpParams;
+    delete(param: string, value?: string | number | boolean): HttpParams;
+    toString(): string;
+}

package/dist/index.d.ts

@@ -2,9 +2,47 @@ export { SCOPES, DEFAULT_SCOPE, SCOPE_LIFETIME_RANK, isScopeViolation } from "./
 export type { Scope } from "./scope";
 export { InjectionToken } from "./token";
 export type { InjectionTokenOptions } from "./token";
-export { isClassProvider, isExistingProvider, isFactoryProvider, isValueProvider, } from "./provider";
-export type { ClassProvider, ExistingProvider, FactoryProvider, Provider, Token, Type, ValueProvider, } from "./provider";
-export { Command, Controller, Delete, Get, Inject, Injectable, Module, Patch, Post, Put, Query, getCommandMeta, getControllerMeta, getInjectParams, getInjectableMeta, getModuleMeta, getQueryMeta, getRoutes, COMMAND_METADATA, CONTROLLER_METADATA, INJECTABLE_METADATA, INJECT_PARAMS_METADATA, MODULE_METADATA, QUERY_METADATA, ROUTES_METADATA, } from "./decorators";
-export type { CommandMeta, CommandOptions, ControllerMeta, HttpMethod, InjectableMeta, InjectableOptions, ModuleMeta, ModuleOptions, QueryMeta, QueryOptions, RouteDefinition, RouteOptions, } from "./decorators";
+export { flattenProviders, isEnvironmentProviders, isClassProvider, isExistingProvider, isFactoryProvider, isValueProvider, makeEnvironmentProviders, provideAppInitializer, provideEnvironmentInitializer, provideToken, } from "./provider";
+export type { ClassProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, Provider, Token, Type, ValueProvider, } from "./provider";
+export { Body, CanDeactivate, Command, Controller, Data, Delete, Get, Head, Headers, Host, Inject, Injectable, Module, Optional, Options, Param, Patch, Post, Put, Query, Resolve, Self, SkipSelf, Title, UseGuards, executeResolvers, getCommandMeta, getControllerMeta, getGuards, getHostParams, getInjectParams, getOptionalParams, getRouteParams, getSelfParams, getSkipSelfParams, getInjectableMeta, getModuleMeta, getQueryMeta, getRoutes, COMMAND_METADATA, CONTROLLER_METADATA, GUARDS_METADATA, CAN_DEACTIVATE_METADATA, HOST_PARAMS_METADATA, INJECTABLE_METADATA, INJECT_PARAMS_METADATA, RESOLVE_METADATA, OPTIONAL_PARAMS_METADATA, ROUTE_PARAMS_METADATA, SELF_PARAMS_METADATA, SKIP_SELF_PARAMS_METADATA, MODULE_METADATA, QUERY_METADATA, ROUTES_METADATA, } from "./decorators";
+export type { CanActivateFn, CanDeactivateFn, CanMatchFn, CommandMeta, CommandOptions, ControllerMeta, ControllerOptions, HttpMethod, InjectableMeta, InjectableOptions, ModuleMeta, ModuleOptions, ParamOptions, QueryMeta, QueryOptions, ResolveFn, RouteDefinition, RouteOptions, RouteParamBinding, } from "./decorators";
 export { defineModule } from "./module";
-export { DB_CLIENT, JOB_CONTEXT, REQUEST_CONTEXT } from "./context";
+export { APP_INITIALIZER, DB_CLIENT, DESTROY_REF, ENVIRONMENT_INITIALIZER, JOB_CONTEXT, REQUEST_CONTEXT, createDestroyRef, } from "./context";
+export type { DestroyRef, OnDestroy } from "./context";
+export { INJECTOR, assertInInjectionContext, createChildInjector, createEnvironmentInjector, getActiveInjector, inject, injectAll, injectDestroySignal, runInInjectionContext, } from "./inject";
+export type { EnvironmentInjector, InjectFlags, InjectorLike } from "./inject";
+export { forwardRef, isForwardRef, resolveForwardRef } from "./forward_ref";
+export type { ForwardRefFn } from "./forward_ref";
+export { matchRoute } from "./route_match";
+export type { RouteMatchResult } from "./route_match";
+export { createBearerAuthInterceptor, createHeaderInterceptor, createRetryInterceptor, createTimeoutInterceptor, withInterceptors, } from "./interceptor";
+export type { HttpInterceptorFn, HttpRequestPayload } from "./interceptor";
+export { computed, effect, linkedSignal, signal, untracked, } from "./signal";
+export type { LinkedSignalOptions, Signal, WritableSignal } from "./signal";
+export { resource } from "./resource";
+export type { ResourceLoaderParams, ResourceOptions, ResourceRef, ResourceStatus, } from "./resource";
+export { RedirectCommand, executeRoutePipeline, isRedirectCommand, } from "./route_pipeline";
+export type { NavigationExtras, RoutePipelineContext, RoutePipelineDefinition, RoutePipelineOptions, RoutePipelineResult, RouterEvent, RouterEventType, } from "./route_pipeline";
+export { TestBed } from "./testing";
+export type { TestModuleMetadata } from "./testing";
+export { APP_BASE_HREF, ROUTER_CONFIGURATION, ROUTE_CONFIG, provideRouter, withComponentInputBinding, withRouterConfig, withTitleStrategy, } from "./route_provider";
+export type { RouterConfigOptions, RouterFeature } from "./route_provider";
+export { DefaultTitleStrategy, TITLE_STRATEGY, TitleStrategy, } from "./title_strategy";
+export { joinWithSlash, normalizePath, stripTrailingSlash, } from "./location";
+export { TransferState, TRANSFER_STATE, makeStateKey, } from "./transfer_state";
+export type { StateKey } from "./transfer_state";
+export { DOCUMENT, PLATFORM_BROWSER_ID, PLATFORM_EDGE_ID, PLATFORM_ID, PLATFORM_SERVER_ID, detectPlatform, isPlatformBrowser, isPlatformEdge, isPlatformServer, } from "./platform";
+export type { PlatformId } from "./platform";
+export { HttpParams } from "./http_params";
+export type { HttpParamsOptions } from "./http_params";
+export { HttpHeaders } from "./http_headers";
+export { HttpContext, HttpContextToken } from "./http_context";
+export { HTTP_CLIENT_CONFIG, HTTP_INTERCEPTORS, HttpClient, HttpErrorResponse, provideHttpClient, withFetch, withRequestsMadeViaParent, } from "./http_client";
+export type { HttpClientConfig, HttpClientFeature, HttpClientFeatureKind, HttpRequestOptions, } from "./http_client";
+export { DefaultUrlSerializer, UrlSegmentGroup, UrlSerializer, UrlTree, } from "./url_tree";
+export type { UrlSegment } from "./url_tree";
+export { AbstractControl, FormArray, FormControl, FormGroup, Validators, } from "./forms";
+export type { AbstractControlOptions, AsyncValidatorFn, FormControlStatus, ValidationErrors, ValidatorFn, } from "./forms";
+export { booleanAttribute, numberAttribute, } from "./input_transform";
+export { DatePipe, JsonPipe, LowerCasePipe, Pipe, TrimPipe, UpperCasePipe, getPipeMetadata, } from "./pipe";
+export type { PipeMetadata, PipeTransform, } from "./pipe";