@sitecore-content-sdk/angular 0.1.0-canary.20260609132302

package/dist/types/sitecore-content-sdk-angular.d.ts

@@ -0,0 +1,1446 @@
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, InjectionToken, Provider, Signal, Type, ElementRef } from '@angular/core';
+import { Params, ResolveFn, ActivatedRouteSnapshot, RouterStateSnapshot, NavigationError, RedirectCommand, Router, UrlMatcher, DefaultUrlSerializer, UrlTree } from '@angular/router';
+import { SitecoreClient, Page } from '@sitecore-content-sdk/content/client';
+export { DefaultRetryStrategy, ErrorPage, GraphQLClientError, GraphQLRequestClient, GraphQLRequestClientFactoryConfig, Page, PageMode, RetryStrategy, SitecoreClient } from '@sitecore-content-sdk/content/client';
+import { SitecoreConfig, SitecoreConfigInput } from '@sitecore-content-sdk/content/config';
+export { CacheClient, CacheOptions, ClientError, MemoryCacheClient, NativeDataFetcher, NativeDataFetcherConfig, NativeDataFetcherResponse, constants, enableDebug } from '@sitecore-content-sdk/core';
+import * as _sitecore_content_sdk_content_layout from '@sitecore-content-sdk/content/layout';
+import { ComponentRendering, RouteData, TextField, LinkField, LinkFieldValue } from '@sitecore-content-sdk/content/layout';
+export { ComponentFields, ComponentParams, ComponentRendering, EditMode, Field, ImageField, ImageFieldValue, ImageSizeParameters, Item, LayoutService, LayoutServiceContext, LayoutServiceContextData, LayoutServiceData, LayoutServicePageState, LinkField, LinkFieldValue, RichTextField, RouteData, TextField, getChildPlaceholder, getContentStylesheetLink, getDesignLibraryStylesheetLinks, getFieldValue } from '@sitecore-content-sdk/content/layout';
+import { Driver } from 'unstorage';
+import * as _sitecore_content_sdk_angular from '@sitecore-content-sdk/angular';
+import { SiteInfo } from '@sitecore-content-sdk/content/site';
+export { SitePathService, SitePathServiceConfig } from '@sitecore-content-sdk/content/site';
+import { DictionaryPhrases } from '@sitecore-content-sdk/content/i18n';
+export { getLocaleRewrite } from '@sitecore-content-sdk/content/i18n';
+import { TranslateLoader } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+export { isEditorActive, resetEditorChromes } from '@sitecore-content-sdk/content/editing';
+export { mediaApi } from '@sitecore-content-sdk/content/media';
+
+/**
+ * Sitecore configuration input for Angular apps. Extends the base
+ * {@link SitecoreConfigInput} with an `angular` section. `redirects.locales` is intentionally
+ * omitted from the input — it is derived from `angular.locales` so there is a single
+ * source of truth for the locale list.
+ * @public
+ */
+interface AngularSitecoreConfigInput extends Omit<SitecoreConfigInput, 'redirects'> {
+    /**
+     * Settings for redirects functionality. `locales` is derived automatically from
+     * `angular.locales`; only `enabled` is configurable at this layer.
+     */
+    redirects?: Omit<NonNullable<SitecoreConfigInput['redirects']>, 'locales'>;
+    /** Angular-specific configuration. */
+    angular?: {
+        /**
+         * Locales supported by the Angular app.
+         * `defaultLanguage` is prepended automatically when absent.
+         */
+        locales?: string[];
+        /**
+         * Configuration for the ISR-like cache. Both fields default when omitted
+         * (`enabled: true`, `revalidate: 300`).
+         */
+        loadersCache?: {
+            /** Whether the cache is enabled. */
+            enabled?: boolean;
+            /** The global revalidate time in seconds. */
+            revalidate?: number;
+        };
+    };
+}
+/**
+ * Resolved Sitecore configuration for Angular apps. Extends the fully-resolved
+ * {@link SitecoreConfig}; structurally still a `SitecoreConfig`, so existing callers that
+ * type the value as `SitecoreConfig` continue to work. `redirects.locales` is intentionally
+ * omitted at the type level — read the canonical locale list from `angular.locales`.
+ * @public
+ */
+interface AngularSitecoreConfig extends Omit<SitecoreConfig, 'redirects'> {
+    redirects: Omit<SitecoreConfig['redirects'], 'locales'>;
+    angular: {
+        /** Resolved locales for the Angular app. Always contains at least `defaultLanguage`. */
+        locales: string[];
+        /**
+         * Resolved configuration for the ISR-like cache. Defaults are applied by
+         * `defineConfig`: `enabled: true`, `revalidate: 300`.
+         */
+        loadersCache: {
+            enabled: boolean;
+            revalidate: number;
+        };
+    };
+}
+/**
+ * Merges `clientEnv` (browser-safe `environment*.ts`) with `process.env` for server-only variables,
+ * then delegates to the base content `defineConfig` and adds the Angular-specific config layer.
+ *
+ * - `angular.locales` is the single source of truth for the locale list; `defaultLanguage` is
+ *   added when missing.
+ * - `redirects.locales` is overwritten from `angular.locales` so the redirects proxy stays in sync.
+ *
+ * On Node/SSR, load `.env` in the app entry before importing `sitecore.config` (see
+ * `load-env.ts` in the sample).
+ * @param {AngularSitecoreConfigInput} [config] - Base Sitecore configuration input.
+ * @param {Record<string, string | undefined>} [clientEnv] - Browser-safe env from `environment*.ts`.
+ * @returns {AngularSitecoreConfig} Fully merged Sitecore configuration for Angular.
+ * @public
+ */
+declare function defineConfig(config?: AngularSitecoreConfigInput, clientEnv?: Record<string, string | undefined>): AngularSitecoreConfig;
+
+/**
+ * Configuration for the Sitecore Angular SDK.
+ * @public
+ */
+interface AngularCSDKAppInit {
+    /**
+     * Sitecore configuration (e.g. from sitecore.config.ts).
+     * When provided, {@link sitecoreClient} must also be set; both are registered for DI.
+     */
+    sitecoreConfig?: AngularSitecoreConfig;
+    /**
+     * Application-owned {@link SitecoreClient} instance (e.g. from a module singleton).
+     * Required when {@link sitecoreConfig} is set; registered as {@link SITECORE_CLIENT_TOKEN}.
+     */
+    sitecoreClient?: SitecoreClient;
+    notFoundRoute?: string;
+    errorRoute?: string;
+}
+/**
+ * Provides Sitecore Angular SDK services to the application.
+ * Call this in your `app.config.ts` `providers` array.
+ * @param {AngularCSDKAppInit} init SDK configuration
+ * @param {AngularCSDKAppInit} init.sitecoreConfig - Sitecore configuration
+ * @param {AngularCSDKAppInit} init.sitecoreClient - Sitecore client
+ * @param {AngularCSDKAppInit} init.notFoundRoute - Not found route
+ * @param {AngularCSDKAppInit} init.errorRoute - Error route
+ * @returns {EnvironmentProviders} Angular environment providers
+ * @example
+ * // app.config.ts
+ * import scConfig from '../sitecore.config';
+ * import { getClient } from '../content-sdk/client/sitecore-client';
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideSitecoreAngular({ sitecoreConfig: scConfig, sitecoreClient: getClient() }),
+ *   ],
+ * };
+ * @public
+ */
+declare function provideSitecoreAngular(init: AngularCSDKAppInit): EnvironmentProviders;
+
+/**
+ * Injection token for the Sitecore configuration.
+ * Provided by `provideSitecoreAngular({ sitecoreConfig, sitecoreClient })`. Inject this to read config app-wide.
+ * `AngularSitecoreConfig` extends `SitecoreConfig`, so consumers that previously typed the
+ * value as `SitecoreConfig` remain structurally compatible.
+ * @public
+ */
+declare const SITECORE_CONFIG_TOKEN: InjectionToken<AngularSitecoreConfig>;
+/**
+ * Injection token for the SitecoreClient instance.
+ * Provided by `provideSitecoreAngular({ sitecoreConfig, sitecoreClient })` with the app-supplied client instance.
+ * @public
+ */
+declare const SITECORE_CLIENT_TOKEN: InjectionToken<SitecoreClient>;
+
+/**
+ * Resolves layout/page data for a route path using a {@link SitecoreClient} and Sitecore config.
+ * Import your `sitecore.config` default and shared client (e.g. `getClient()`) from the app;
+ * this stays usable from route loaders without Angular injection context.
+ *
+ * Future: add helpers for personalization and multisite alongside this call.
+ * @param {string} path - Route path (e.g. `'/'` or `'/about'`).
+ * @param {AngularSitecoreConfig} sitecoreConfig - Resolved Sitecore configuration (e.g. default export from `sitecore.config.ts`).
+ * @param {SitecoreClient} client - Sitecore client instance (e.g. from a module singleton).
+ * @param {{ locale?: string; site?: string }} [options] - Optional `locale` / `site` overrides.
+ * @param {string} [options.locale] - Optional locale override.
+ * @param {string} [options.site] - Optional site override.
+ * @returns {Promise<Page | null>} Page layout data, or `null` if not found.
+ * @public
+ */
+declare function resolveSitecorePage(path: string, sitecoreConfig: AngularSitecoreConfig, client: SitecoreClient, options?: {
+    locale?: string;
+    site?: string;
+}): Promise<Page | null>;
+
+/**
+ * Request context containing information from the incoming HTTP request.
+ * Used for request-dependent operations in loaders.
+ * @public
+ */
+interface RequestContext {
+    /**
+     * The hostname from the request (without port)
+     */
+    hostname?: string;
+    /**
+     * Cookies from the request
+     */
+    cookies?: Record<string, string>;
+    /**
+     * Query parameters from the request
+     */
+    query?: Record<string, string | string[] | undefined>;
+    /**
+     * Headers from the request
+     */
+    headers?: Record<string, string | string[] | undefined>;
+}
+/**
+ * Context provided to loader functions.
+ * Contains information about the current request including URL, params, query, and request context.
+ * @public
+ */
+type LoaderContext = {
+    /**
+     * The current URL path
+     */
+    url: string;
+    /**
+     * Route parameters from all matched segments.
+     *
+     * When locales are configured and the route tree uses `scLocaleMatcher`, the matched
+     * locale is exposed as `params.locale`. The resolver also defaults `params.locale` to
+     * `defaultLanguage` from `sitecore.config` when no locale segment was matched — loaders
+     * can rely on a concrete `params.locale` regardless of URL shape.
+     */
+    params: Params;
+    /**
+     * Query string parameters
+     */
+    query: Record<string, string | string[]>;
+    /**
+     * Server-only: the incoming request
+     */
+    req?: Request;
+    /**
+     * Server-only: the response object
+     */
+    res?: Response;
+    /**
+     * Server-only: context from the incoming HTTP request.
+     * Contains hostname, cookies, query params, and headers.
+     * Use with createSiteResolver() to determine the current site.
+     * @example
+     * ```typescript
+     * const resolveSite = createSiteResolver({ sites, defaultSite: config.defaultSite });
+     *
+     * export const pageLoader: LoaderFn = async (ctx) => {
+     *   if (ctx.requestContext) {
+     *     const { site } = resolveSite(ctx.requestContext);
+     *     return client.getPage(ctx.url, { site: site.name });
+     *   }
+     *   return client.getPage(ctx.url);
+     * };
+     * ```
+     */
+    requestContext?: RequestContext;
+};
+type LoaderApiRequest = {
+    loaderId: string;
+    url: string;
+    params: Params;
+    query: Record<string, any>;
+    /**
+     * Server-derived request context (hostname, headers, cookies, query).
+     * Populated once at the request boundary (`/_data` middleware closure or the
+     * SSR resolver). Downstream code reads this directly; nobody re-extracts.
+     * Phase 2 of the refactor plan.
+     */
+    angularRequestContext?: RequestContext;
+    /**
+     * Per-route cache overrides supplied at the `loaderResolver(id, cacheOptions)`
+     * call site. The browser includes them in the `/_data` POST body so the same
+     * per-route policy applies on CSR navigations. Phase 5 of the refactor plan.
+     */
+    cacheOptions?: LoaderCacheConfig;
+};
+type LoaderRedirectResult = {
+    loaderRedirectTarget: string;
+    status?: number;
+};
+type LoaderApiResponse = {
+    kind: 'data';
+    data: any;
+} | {
+    kind: 'redirect';
+    redirect: LoaderRedirectResult;
+} | {
+    kind: 'error';
+    status: number;
+    message: string;
+} | {
+    kind: 'notFound';
+    status: number;
+};
+/**
+ * Result returned by loader resolution on the server (SSR and `/_data` endpoint).
+ * Uses the shared cross-boundary loader registry; not a separate server loader set.
+ * @public
+ */
+type LoaderDataResult = {
+    kind: 'data';
+    data: unknown;
+} | {
+    kind: 'redirect';
+    redirect: LoaderRedirectResult;
+} | {
+    kind: 'error';
+    status: number;
+    message: string;
+    cause?: unknown;
+};
+/**
+ * Loader function type.
+ * A loader is an async function that receives context, can be applied in route resolvers and can return:
+ * - data - any data that can be serialized and stored in the transfer state
+ * - redirect - a redirect to be applied to the router
+ * - throw error - an error that occurred during the retrieval of the data
+ * @public
+ */
+type LoaderFn<T = unknown> = (ctx: LoaderContext) => Promise<T> | T | LoaderRedirectResult;
+declare class NotFoundNavigationError extends Error {
+    constructor(message?: string);
+}
+declare class LoaderHttpError extends Error {
+    status: number;
+    constructor(status: number, message?: string);
+}
+/**
+ * Base browser-safe config type for loader cache.
+ *
+ * `revalidate` is in seconds. A positive value caches the entry for that many
+ * seconds; `0` or a negative value means "never expire" (rely on explicit
+ * invalidation). There is no `'infinite'` sentinel.
+ * @public
+ */
+interface LoaderCacheConfig extends PerRouteLoaderCacheConfig {
+    /** Default site name for tag helpers and admin tooling. Defaults to `'default'`. */
+    defaultSiteName?: string;
+    /**
+     * Site names used by revalidation middleware to fan out dictionary loader tags
+     * (`sc:loader:dictionary:<site>:<locale>`) on every webhook call.
+     */
+    sites?: string[];
+    /** Fallback locale for tag helpers when a site entry has no `language`. Defaults to `'en'`. */
+    defaultLocale?: string;
+}
+/**
+ * Per-route cache configuration.
+ * @public
+ */
+interface PerRouteLoaderCacheConfig {
+    /** TTL in seconds. Positive → expires after N seconds; `0` or negative → never expires. */
+    revalidate?: number;
+    /** Master switch — when false, every call falls through to the raw loader. */
+    enabled?: boolean;
+    /**
+     * Custom tags applied to every entry this loader writes. Merged with built-in
+     * OSR tags (self-key, `sc:site`, `sc:locale`, and `sc:item` for page loaders).
+     */
+    tags?: string[];
+}
+/**
+ * Metadata returned by cache.entries() — sufficient for an admin UI without
+ * shipping the cached values themselves (which can be large).
+ * @public
+ */
+interface LoaderCacheEntryInfo {
+    key: string;
+    tags: string[];
+    storedAt: number;
+    expiresAt: number | null;
+    stale: boolean;
+}
+/**
+ * Three-outcome read result for stale-while-revalidate (Phase 3).
+ *
+ * - `hit` — entry is fresh; serve cached value without running the loader.
+ * - `stale` — entry expired or was invalidated; serve cached value and refresh in the background.
+ * - `miss` — no entry; run the loader synchronously.
+ * @public
+ */
+type LoaderCacheReadResult = 
+/** Fresh cache entry within TTL and not marked stale. */
+{
+    kind: 'hit';
+    value: unknown;
+    cacheKey: string;
+}
+/** Expired or invalidated entry; value is served while a background refresh runs. */
+ | {
+    kind: 'stale';
+    value: unknown;
+    cacheKey: string;
+}
+/** No entry stored for the requested cache key. */
+ | {
+    kind: 'miss';
+    cacheKey: string;
+};
+/**
+ * Tag-based invalidation input.
+ * Marks matching entries stale via the tag index; does not delete them (SWR semantics).
+ * @public
+ */
+interface InvalidateInput {
+    /** Non-empty list of OSR tags (for example `sc:item:…`, `sc:site:…`, or a cache key self-tag). */
+    tags?: string[];
+}
+/**
+ * Server-only cache instance. Constructed once in `server.ts` via
+ * `createLoaderCache` (see `server/cache`) and passed by reference to middleware factories
+ * (`createLoaderDataServiceMiddleware`, `createCacheAdminMiddleware`,
+ * `createSitecoreRevalidateMiddleware`; see `server/middleware`) and to Angular SSR through
+ * `angularApp.handle(req, { cache })`.
+ *
+ * Implementations maintain a sidecar tag index so `LoaderCache.invalidate`
+ * can mark entries stale without scanning every key.
+ * @public
+ */
+interface LoaderCache {
+    /** Global default TTL in seconds from {@link LoaderCacheConfig.revalidate}. */
+    get ttl(): number;
+    /** Resolved configuration (useful for admin UI and diagnostics). */
+    get config(): Readonly<LoaderCacheConfig>;
+    /**
+     * Reads a cache entry and classifies it as hit, stale, or miss.
+     * @param key - OSR-aligned cache key (for example `sc:loader:page:demo:en:default:about`).
+     */
+    get(key: string): Promise<LoaderCacheReadResult>;
+    /**
+     * Stores an entry and links it to the supplied tag set.
+     * @param key - Cache key to write.
+     * @param value - Loader payload to persist.
+     * @param ttlSeconds - TTL in seconds; `0` or negative means never expire.
+     * @param tags - Tag index pointers written alongside the entry (self-key, site, locale, item, etc.).
+     */
+    set(key: string, value: unknown, ttlSeconds: number, tags: string[]): Promise<void>;
+    /**
+     * Marks every entry linked to any of the supplied tags as stale.
+     * @param filter - Tag list to resolve through the tag index.
+     * @returns Number of entries marked stale (includes entries already stale).
+     */
+    invalidate(filter: InvalidateInput): Promise<number>;
+    /** Removes a single entry and unlinks it from the tag index. */
+    delete(key: string): Promise<boolean>;
+    /** Removes every entry and clears the tag index. */
+    flush(): Promise<void>;
+    /** Returns lightweight metadata for admin tooling (values are omitted). */
+    entries(): Promise<LoaderCacheEntryInfo[]>;
+    /** Whether caching is enabled globally. Per-route overrides may still opt in. */
+    enabled(): boolean;
+}
+
+/**
+ * Extension point for custom loader IDs. Augment this interface so that
+ * loaderResolver() accepts your loader ids when you add them via provideLoaderRegistry().
+ * @example
+ * // In your app (e.g. app.d.ts or a types file):
+ * declare module '@sitecore-content-sdk/angular' {
+ *   interface LoaderIdMap {
+ *     myCustomLoader: void;
+ *   }
+ * }
+ * // Then provideLoaderRegistry({ myCustomLoader: myLoader }) and loaderResolver('myCustomLoader') are typed.
+ */
+interface LoaderIdMap {
+}
+/** Loader ID type. Use string keys that match the keys you pass to provideLoaderRegistry. */
+type LoaderId = keyof LoaderIdMap extends never ? string : keyof LoaderIdMap;
+/**
+ * Create a loader resolver function that resolver loader data with optional cache options on server or browser.
+ * @param {LoaderId} loaderId - The loader ID
+ * @param {PerRouteLoaderCacheConfig} [cacheOptions] - The cache options
+ * @returns {ResolveFn<unknown>} loader resolver function
+ */
+declare const loaderResolver: (loaderId: LoaderId, cacheOptions?: PerRouteLoaderCacheConfig) => ResolveFn<unknown>;
+
+/**
+ * Optional endpoint path for loader data fetch (e.g. '/_data' or '/api/data').
+ * When null or undefined, LOADER_DATA_ENDPOINT is used.
+ * @public
+ */
+declare const FETCH_DATA_ENDPOINT: InjectionToken<string | null | undefined>;
+/**
+ * Cross-boundary loader registry — maps loader IDs to loader functions.
+ * The same registry is used for SSR, CSR (`/_data`), and route resolvers.
+ * There is no separate server vs client loader set.
+ * @public
+ */
+type LoaderRegistry = Record<string, LoaderFn>;
+declare const LOADER_REGISTRY: InjectionToken<LoaderRegistry>;
+/**
+ * Registers the app's loader registry for DI. Pass the loaders your app uses
+ * (e.g. page, '404', '500'). Use the **same object** with
+ *createLoaderDataServiceMiddleware in `server.ts` so SSR and CSR
+ * navigations resolve the same loader functions.
+ * @param {LoaderRegistry} loaders - Map of loader id to loader function
+ * @public
+ */
+declare const provideLoaderRegistry: (loaders: LoaderRegistry) => Provider[];
+/**
+ * Symbol used to tag resolver functions with their loader ID.
+ * This allows the prefetch service to identify loader resolvers in the route tree.
+ * @internal
+ */
+declare const LOADER_ID: unique symbol;
+
+/**
+ * Request parameters for fetching loader data
+ * @public
+ */
+interface LoaderDataRequest {
+    url: string;
+    loaderId: string;
+    params?: Params;
+    query?: Record<string, string | string[]>;
+    /**
+     * Per-route cache overrides from `loaderResolver(id, cacheOptions)`. Sent
+     * to the server in the POST body so server-side cache policy matches the
+     * route's intent on CSR navigations. Phase 5 of the refactor plan.
+     */
+    cacheOptions?: LoaderCacheConfig;
+}
+/**
+ * Loader data client for browser loader data resolution. POSTs to the `/_data` endpoint and holds
+ * short-lived prefetched responses for parallel navigation prefetching.
+ * Not aware of the server-side {@link LoaderCache}.
+ * @public
+ */
+declare class ClientLoaderDataService {
+    private readonly prefetchedResponses;
+    private readonly pending;
+    private readonly http;
+    private readonly platformId;
+    private readonly fetchDataEndpoint;
+    /**
+     * Prefetch loader data for the given request without consuming staged responses.
+     * If a response is already staged or a request is pending, does nothing.
+     * Otherwise starts a fetch and stores the result for a later getData() call.
+     * Used by PreLoaderDataService to warm responses for all loaders in a route in parallel.
+     * @param {LoaderDataRequest} loaderRequest - The loader data request
+     */
+    prefetch(loaderRequest: LoaderDataRequest): void;
+    /**
+     * Get data for the given request, using staged prefetched responses or fetching if needed.
+     * If a request is already pending for this URL/loader combination,
+     * waits for it to complete instead of making a duplicate request.
+     * Consumes (removes) staged responses after retrieval.
+     * @param {LoaderDataRequest} request - The loader data request
+     * @returns {Promise<LoaderApiResponse>} Promise resolving to the API response
+     */
+    getData(request: LoaderDataRequest): Promise<LoaderApiResponse>;
+    /**
+     * Fetch data from the configured data endpoint.
+     * Callers (getData, prefetch) add the returned promise to pending; it is removed
+     * in finally when the promise settles.
+     * @param {LoaderDataRequest} request - The loader data request
+     * @returns {Promise<LoaderApiResponse>} Promise resolving to the API response
+     */
+    private fetchData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientLoaderDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientLoaderDataService>;
+}
+
+/**
+ * ClientPreLoaderDataService kicks off loader data fetches for all loaders in the current route
+ * and its parent routes in parallel, so that when Angular runs resolvers sequentially,
+ * resolvers get staged prefetched responses or join already-pending requests instead of waiting.
+ *
+ * Subscribes to the router's ActivationStart event and prefetches for the
+ * ActivatedRouteSnapshot when it is the leaf route (browser only). Discovers all loader
+ * resolvers on that snapshot and its parents (via LOADER_ID on pathFromRoot), then
+ * calls ClientLoaderDataService.prefetch() for each (loaderId, url, params, query). Fetches
+ * run in parallel; results are stored in ClientLoaderDataService prefetchedResponses for getData() to consume.
+ * @public
+ */
+declare class ClientPreLoaderDataService {
+    private readonly loaderData;
+    private readonly platformId;
+    private readonly router;
+    private readonly destroyRef;
+    constructor();
+    /**
+     * Prefetch loader data for all loaders in the route tree.
+     * Call this at the start of browser resolver execution so all loaders for the route
+     * are kicked off in parallel before resolvers run sequentially.
+     * No-op on server.
+     * @param {ActivatedRouteSnapshot} route - Current route (pathFromRoot gives current and parent routes)
+     * @param {RouterStateSnapshot} state - Current router state (use state.url for the navigation URL)
+     */
+    prefetchForRoute(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<void>;
+    /**
+     * Collect LoaderDataRequest for each resolver that has LOADER_ID on the current route
+     * and its parent routes (pathFromRoot). Deduplicates by (loaderId, url).
+     * @param {ActivatedRouteSnapshot} route - The current route
+     * @param {RouterStateSnapshot} state - The router state snapshot, used for url and params
+     */
+    private collectLoaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientPreLoaderDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientPreLoaderDataService>;
+}
+
+/**
+ * SSR injection port for cache-aware loader resolution.
+ * Implemented by `ServerLoaderRunner` and wired via
+ * `provideServerLoaderRunner` (see the `server/express` module).
+ * @public
+ */
+interface ServerLoaderRunnerPort {
+    /**
+     * Resolve loader data on the server (cache-aware) using the shared {@link LOADER_REGISTRY}.
+     * @param {LoaderApiRequest} request - Loader request payload
+     * @returns {Promise<LoaderDataResult>} Resolved loader result
+     */
+    resolve(request: LoaderApiRequest): Promise<LoaderDataResult>;
+}
+/**
+ * Injection token for SSR loader data resolution.
+ * Must be provided via `provideServerLoaderRunner` in server application config.
+ * @public
+ */
+declare const SERVER_LOADER_RUNNER: InjectionToken<ServerLoaderRunnerPort>;
+
+/**
+ * Returns a navigation error handler for use with withNavigationErrorHandler.
+ * Delegates to {@link redirectOnNavigationError}.
+ * @returns A handler compatible with `provideRouter(routes, withNavigationErrorHandler(...))`
+ * @public
+ */
+declare function handleNavigationError(): (error: NavigationError) => RedirectCommand | void;
+
+/**
+ * Apply a redirect: internal URLs → RedirectCommand; external URLs → full page navigation.
+ * Use in resolvers and in the navigation error handler (fallback) so redirect behavior is consistent.
+ * Redirects are not errors; this helper is the single place that defines how to perform them.
+ * @param {Router} router - Angular Router (for internal redirects)
+ * @param {string} location - Target URL (path or full URL)
+ * @returns RedirectCommand for internal, void after window.location.assign for external
+ * @public
+ */
+declare function applyRedirect(router: Router, location: string): RedirectCommand | void;
+
+/**
+ * Default path for the data endpoint used by loaders.
+ * This path will be requested by the client-side loader resolver to fetch data for the current route.
+ * @public
+ */
+declare const LOADER_DATA_ENDPOINT = "/_data";
+
+/**
+ * Minimal Express Request interface for type safety without requiring Express as a dependency
+ * @public
+ */
+interface ExpressRequest {
+    method: string;
+    path: string;
+    url: string;
+    body: unknown;
+    query: Record<string, string | string[] | undefined>;
+    /**
+     * Cookies from the request (requires cookie-parser middleware)
+     */
+    cookies?: Record<string, string>;
+    /**
+     * Headers from the request
+     */
+    headers?: Record<string, string | string[] | undefined>;
+}
+/**
+ * Minimal Express Response interface for type safety without requiring Express as a dependency
+ * @public
+ */
+interface ExpressResponse {
+    status(code: number): ExpressResponse;
+    json(data: unknown): void;
+}
+/**
+ * Configuration for server-side data handlers
+ * @public
+ */
+interface DataHandlerConfig {
+    /**
+     * The endpoint path for the data handler.
+     * @default '/_data'
+     */
+    endpoint?: string;
+}
+/**
+ * Express next function type
+ * @public
+ */
+type ExpressNextFunction = (error?: unknown) => void;
+/**
+ * Express-compatible middleware type
+ * @public
+ */
+type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => void | Promise<void>;
+
+/**
+ * Options for the Express data handler
+ * @public
+ */
+interface ExpressDataHandlerOptions extends DataHandlerConfig {
+    /**
+     * The shared loader registry (same object as provideLoaderRegistry).
+     */
+    loaders: LoaderRegistry;
+    /**
+     * Optional loader cache. When supplied, /_data responses go through
+     * cache-aside; omit to run loaders directly on every request.
+     */
+    cache?: LoaderCache;
+    /**
+     * Optional request context extractor (e.g. for testing via TestBed).
+     * If not provided, uses the default implementation from loaders/utils.
+     * @internal
+     */
+    extractRequestContext?: (req: ExpressRequest) => RequestContext;
+}
+
+/**
+ * Server-side cache aware loader data resolver.
+ * LoaderResolver is exposed to both server and browser. This layer ensures browser safety and acts as connecting layer to cache.
+ *
+ * Resolution order when a {@link LoaderCache} is attached:
+ * 1. **hit** — return cached value immediately.
+ * 2. **stale** — return cached value immediately and schedule a background refresh
+ *    (coalesced per cache key via `pendingCacheOps`).
+ * 3. **miss** — run the loader, persist the result with OSR tags, return data.
+ *
+ * Redirect responses are never cached. Per-route LoaderCacheConfig overrides
+ * from `loaderResolver(id, cacheOptions)` control TTL, tags, and opt-in caching when
+ * the global cache is disabled.
+ * @public
+ */
+declare class ServerLoaderRunner {
+    private readonly registry;
+    private readonly cache?;
+    /** Process-wide coalescing for stale-while-revalidate background refreshes. */
+    private static readonly pendingCacheOps;
+    /**
+     * @param {LoaderRegistry} registry - Same loader map as `provideLoaderRegistry` / `/_data` middleware.
+     * @param {LoaderCache | undefined} cache - Optional cache instance from createLoaderCache.
+     */
+    constructor(registry: LoaderRegistry, cache?: LoaderCache | undefined);
+    /**
+     * Resolve loader data with optional cache read-through and SWR refresh.
+     * @param {LoaderApiRequest} request - Loader id, URL, params, optional request context and cache overrides.
+     * @returns {Promise<LoaderDataResult>} Data, redirect, or error result for the middleware / SSR resolver.
+     */
+    resolve(request: LoaderApiRequest): Promise<LoaderDataResult>;
+    /**
+     * Fire-and-forget SWR refresh; skipped when a refresh is already in flight for the key.
+     * @param {LoaderApiRequest} request - The loader request
+     * @param {LoaderContext} ctx - The loader context
+     * @param {string} cacheKey - The cache key
+     * @param {LoaderApiRequest['cacheOptions']} cacheOptions - The cache options
+     */
+    private scheduleBackgroundRefresh;
+    private runLoader;
+}
+
+/**
+ * Wires SSR {@link SERVER_LOADER_RUNNER} to ServerLoaderRunner
+ * using the shared {@link LOADER_REGISTRY}. Include in server application providers
+ * alongside provideLoaderRegistry.
+ * @returns Environment providers for SSR loader data resolution
+ * @public
+ */
+declare function provideServerLoaderRunner(): EnvironmentProviders;
+
+/**
+ * Create an Express middleware for the data endpoint.
+ * This middleware handles both GET and POST requests at the configured endpoint path.
+ *
+ * The endpoint path must match the client: provide the same value to the Angular app via
+ * FETCH_DATA_ENDPOINT (e.g. in app.config.ts). There is no Angular DI in Node/Express,
+ * so you pass the endpoint here when calling this function (e.g. from server.ts).
+ * @param {ExpressDataHandlerOptions} options - Handler options: loaders and optional endpoint (defaults to {@link LOADER_DATA_ENDPOINT})
+ * @returns Express middleware that handles the data endpoint
+ * @example
+ * ```typescript
+ * import { createExpressDataMiddleware, LOADER_DATA_ENDPOINT } from '@sitecore-content-sdk/angular';
+ *
+ * // Pass the same LOADERS object used with provideLoaderRegistry(LOADERS)
+ * app.use(createExpressDataMiddleware({ loaders: LOADERS }));
+ *
+ * // Or pass the same endpoint you provide to the Angular app (FETCH_DATA_ENDPOINT)
+ * const dataEndpoint = process.env.DATA_ENDPOINT ?? LOADER_DATA_ENDPOINT;
+ * app.use(createExpressDataMiddleware({ loaders: LOADERS, endpoint: dataEndpoint }));
+ * ```
+ * @public
+ */
+declare function createLoaderDataServiceMiddleware(options: ExpressDataHandlerOptions): ExpressMiddleware;
+/** @public */
+declare const createExpressDataMiddleware: typeof createLoaderDataServiceMiddleware;
+
+/**
+ * Returns a non-empty trimmed secret, or `undefined` when unset or whitespace-only.
+ * @param {string | undefined} secretOption - Explicit secret from handler options.
+ * @param {string | undefined} envValue - Secret from `process.env` (e.g. `SITECORE_REVALIDATE_SECRET`).
+ * @returns {string | undefined} The resolved secret
+ * @internal
+ */
+declare function resolveConfiguredRevalidateSecret(secretOption: string | undefined, envValue: string | undefined): string | undefined;
+/**
+ * Options for {@link createSitecoreRevalidateMiddleware}.
+ * @public
+ */
+interface SitecoreRevalidateMiddlewareOptions {
+    /** Shared cache instance from createLoaderCache call */
+    cache: LoaderCache;
+    /** Default: `process.env.SITECORE_REVALIDATE_SECRET` */
+    secret?: string;
+    /** Locale fallback when an update has no `entity_culture`; default `'en'`. */
+    defaultLocale?: string;
+    /**
+     * When set, every webhook also marks stale one
+     * `sc:loader:dictionary:<site>:<locale>` entry per site (dictionary fan-out).
+     */
+    sites?: SiteInfo[];
+    /** Endpoint path; default `/api/revalidate`. */
+    endpoint?: string;
+}
+/**
+ * Express middleware aligned with Next.js `createSitecoreRevalidateRouteHandler`.
+ *
+ * Handles `POST /api/revalidate` (configurable via `endpoint`):
+ * - Authenticates with `SITECORE_REVALIDATE_SECRET` / `x-revalidate-secret` when configured.
+ * - Parses Experience Edge webhook bodies via {@link collectSitecoreTagsFromEdgeRevalidateRequestBody}.
+ * - Optionally appends dictionary loader tags for each configured site.
+ * - Calls `LoaderCache.invalidate` (marks entries stale; does not delete).
+ *
+ * Response shape: `{ revalidated, tagsCount, marked, invocation_id, continues, durationMs }`.
+ * @param {SitecoreRevalidateMiddlewareOptions} options - The options for the middleware
+ * @returns {ExpressMiddleware} The middleware function
+ * @public
+ */
+declare function createSitecoreRevalidateMiddleware(options: SitecoreRevalidateMiddlewareOptions): ExpressMiddleware;
+
+/**
+ * One content change entry as commonly seen in Experience Edge / Content Operations payloads.
+ * @public
+ */
+type SitecoreEdgeRevalidateUpdate = {
+    identifier?: string;
+    entity_definition?: string;
+    operation?: string;
+    entity_culture?: string;
+};
+/**
+ * Request body shape for webhook-driven revalidation.
+ * @public
+ */
+type SitecoreEdgeRevalidateRequestBody = {
+    invocation_id?: string;
+    updates?: SitecoreEdgeRevalidateUpdate[];
+    continues?: boolean;
+    tags?: string[];
+};
+/**
+ * Strips Experience Edge style suffixes from an `identifier`.
+ * @param {string} identifier - Raw identifier from a webhook update row.
+ * @public
+ */
+declare function extractSitecoreEdgeContentId(identifier: string): string;
+/**
+ * Options for {@link collectSitecoreTagsFromEdgeRevalidateRequestBody}.
+ * @public
+ */
+type CollectSitecoreTagsFromEdgeBodyOptions = {
+    defaultLocale: string;
+};
+/**
+ * Maps an Experience Edge webhook JSON body to Sitecore cache tag strings.
+ *
+ * Accepts fully qualified `sc:…` tags in `body.tags`, raw content identifiers
+ * (with optional `-media`/`-layout` suffixes), and `updates[]` rows with
+ * `identifier` + `entity_culture`.
+ * @param {SitecoreEdgeRevalidateRequestBody | null | undefined} body - Parsed webhook JSON body.
+ * @param {CollectSitecoreTagsFromEdgeBodyOptions} options - Locale fallback when an update omits `entity_culture`.
+ * @returns {string[]} Deduplicated Sitecore cache tags ready for `LoaderCache.invalidate`.
+ * @public
+ */
+declare function collectSitecoreTagsFromEdgeRevalidateRequestBody(body: SitecoreEdgeRevalidateRequestBody | null | undefined, options: CollectSitecoreTagsFromEdgeBodyOptions): string[];
+
+/**
+ * Global config for the loader cache. Consumed by `createLoaderCache()` in
+ * the app's `server.ts`.
+ *
+ * Moved to separate file to avoid accidental `unstorage` imports in browser-safe code.
+ *
+ * Drivers are imported and instantiated in the app (e.g.
+ * `fsDriver({ base: './.cache/loaders' })`) — the package does not own driver
+ * selection. When `driver` is omitted, the cache falls back to its built-in
+ * in-memory implementation.
+ * @public
+ */
+interface GlobalLoaderCacheConfig extends LoaderCacheConfig {
+    /**
+     * Unstorage `Driver` instance. Pass an imported driver — the cache wraps it
+     * with `createStorage({ driver })` internally. Omit for the in-memory default.
+     */
+    driver?: Driver;
+}
+
+/**
+ * Public factory for the loader cache with unstorage backing.
+ * Uses the memory driver by default.
+ *
+ * Drivers are best imported and constructed in the app's `server.ts` and passed here as an instance.
+ * Callers depend on the {@link LoaderCache} interface; concrete classes are not exported.
+ * @param {GlobalLoaderCacheConfig} [config] - Global cache config and optional unstorage driver.
+ * @returns {LoaderCache} Cache implementation with Phase 3 SWR + tag semantics.
+ * @example
+ * ```ts
+ * const cache = createLoaderCache({
+ *   revalidate: config.angular.loadersCache.revalidate,
+ *   enabled: config.angular.loadersCache.enabled,
+ *   defaultSiteName: config.defaultSite,
+ *   driver: fsDriver({ base: './.cache/loaders' }),
+ * });
+ * ```
+ * @public
+ */
+declare function createLoaderCache(config?: GlobalLoaderCacheConfig): LoaderCache;
+
+/**
+ * This middleware is only used for testing and should be removed before release.
+ * TODO: Remove this middleware before release.
+ */
+
+/**
+ * Options for the admin middleware.
+ * @public
+ */
+interface CacheAdminMiddlewareOptions {
+    /** The cache instance to expose. Capture once in `server.ts`. */
+    cache: LoaderCache;
+    /** Base path. Defaults to `/api/_cache`. */
+    endpoint?: string;
+    /**
+     * Optional auth gate. Return true to allow. Defaults to allowing everything,
+     * which is fine for local demos — *do not* leave that default in a deploy.
+     */
+    auth?: (req: ExpressRequest) => boolean;
+}
+/**
+ * Lightweight admin surface for the loader cache:
+ *   GET    <endpoint>/entries        → list entries (metadata only, no values)
+ *   POST   <endpoint>/invalidate     → mark stale by tags (JSON body)
+ *   POST   <endpoint>/flush          → flush every entry
+ *   GET    <endpoint>/config         → resolved config (for the demo UI)
+ * @public
+ */
+declare function createCacheAdminMiddleware(options: CacheAdminMiddlewareOptions): ExpressMiddleware;
+
+/**
+ * Request-scoped Sitecore context derived reactively from the Angular Router.
+ *
+ * - `page` / `dictionary` — from route resolve data (`loaderResolver('page'|'dictionary')`)
+ * - `urlLocale` — from current pathname (SSR REQUEST / window.location, then NavigationEnd)
+ * - `isEditing` / `effectiveLocale` — computed from page + urlLocale + config
+ *
+ * No manual `setPage` / `setDictionary` / `setLocale` wiring required in app components.
+ * @public
+ */
+declare class SitecoreContextService {
+    /** Current Sitecore page data (layout + mode). */
+    readonly page: Signal<Page | null>;
+    /** Current Sitecore dictionary data. */
+    readonly dictionary: Signal<DictionaryPhrases | null>;
+    /** Whether the current page is in editing mode. */
+    readonly isEditing: Signal<boolean>;
+    /**
+     * Locale extracted from the current URL; `null` when no configured-locale prefix
+     * or when locales are not configured.
+     */
+    readonly urlLocale: Signal<string | null>;
+    /**
+     * Effective locale for data fetching: `page.locale ?? urlLocale ?? defaultLanguage`.
+     */
+    readonly effectiveLocale: Signal<string>;
+    private readonly router;
+    private readonly config;
+    private readonly platformId;
+    private readonly req;
+    private readonly isBrowser;
+    private readonly locales;
+    private readonly defaultLanguage;
+    /** Merged resolve data; updates on every completed navigation. */
+    private readonly routeData;
+    /**
+     * Current pathname without query string.
+     * SSR/bootstrap: REQUEST or window.location; client: NavigationEnd.urlAfterRedirects.
+     */
+    private readonly pathname;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SitecoreContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SitecoreContextService>;
+}
+
+/**
+ * `ngx-translate` loader using Sitecore dictionary from {@link SitecoreContextService}.
+ * Requires a `dictionaryLoader` resolver on the active route — without it, `dictionary()`
+ * is `null` and translations resolve to `{}`.
+ * @public
+ */
+declare class SitecoreTranslateLoader implements TranslateLoader {
+    private readonly context;
+    /**
+     * Returns the translation based on the dictionary in the context from {@link SitecoreContextService}.
+     * @returns {Observable<Record<string, string>>} Observable of translation dictionary.
+     */
+    getTranslation(): Observable<Record<string, string>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SitecoreTranslateLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SitecoreTranslateLoader>;
+}
+
+/**
+ * Result of locale extraction from a URL path.
+ * @public
+ */
+interface LocaleExtractionResult {
+    /** Configured locale found at the start of the path, or `null` when absent. */
+    locale: string | null;
+    /** Remainder of the path after the locale segment (always starts with `/`). */
+    nonLocalePath: string;
+    /** Query or fragment string found at the end of the path, or `null` when absent. */
+    queryFragment?: string;
+}
+/**
+ * Extracts a configured locale from the first segment of a URL pathname.
+ * Returns `{ locale: null, nonLocalePath: pathname, queryFragment: query or fragment string }` when the first segment is not a configured locale.
+ * @param {string} pathname - URL pathname, with or without leading `/`.
+ * @param {string[]} locales - Configured locales.
+ * @returns {LocaleExtractionResult} Detected locale and the rest of the path.
+ * @public
+ */
+declare function splitLocaleFromPath(pathname: string, locales: string[]): LocaleExtractionResult;
+/**
+ * Creates an Angular {@link UrlMatcher} that consumes a configured-locale segment from
+ * the start of a route. When the first URL segment matches one of scConfig's `locales`, it is consumed
+ * and exposed as the `locale` route param. Otherwise zero segments are consumed and the
+ * route still matches (so error routes and the catchall handle both prefixed and unprefixed
+ * URLs from the same route tree).
+ * @param {string[]} locales - Configured locales.
+ * @returns {UrlMatcher} Angular URL matcher for locale-prefixed route trees.
+ * @public
+ */
+declare function scLocaleMatcher(locales: string[]): UrlMatcher;
+
+/**
+ * Locale-aware {@link UrlSerializer} replacement. Extends {@link DefaultUrlSerializer} and
+ * prepends the current URL locale (from the request pathname) to every serialized
+ * URL. Angular's built-in `[routerLink]` computes hrefs via `router.serializeUrl()`, which
+ * delegates to the DI-injected `UrlSerializer.serialize()` — so replacing the binding makes
+ * every routerLink href locale-aware with no directive changes.
+ *
+ * Behavior:
+ * - When `currentLocale` is `null` (URL has no configured locale prefix), serialization is
+ *   unchanged.
+ * - When the serialized URL already starts with a configured locale segment, serialization
+ *   is unchanged (mirrors ScLinkDirective idempotency under repeated cycles).
+ * - Otherwise the locale segment is prepended to the serialized URL.
+ *
+ * Parsing is inherited from the default — this serializer does **not** strip locale on
+ * parse. The locale matcher (`scLocaleMatcher`) consumes the locale segment from the
+ * route tree instead.
+ * @public
+ */
+declare class LocaleUrlSerializer extends DefaultUrlSerializer {
+    private readonly locales;
+    private readonly req;
+    private readonly platformId;
+    serialize(tree: UrlTree): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleUrlSerializer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleUrlSerializer>;
+}
+
+/**
+ * SXA uses a special export name to identify the "default" variant.
+ * @public
+ */
+declare const DEFAULT_EXPORT_NAME = "Default";
+type AngularModule = {
+    /** Named variant exports */
+    [key: string]: Type<unknown> | undefined;
+    /** Default component for this rendering */
+    default?: Type<unknown>;
+    /** SXA convention: uppercase Default */
+    Default?: Type<unknown>;
+};
+/**
+ * An entry in the Angular component map. Maps Sitecore rendering names to Angular component types.
+ * Supports SXA rendering variants via named exports alongside a default.
+ * @public
+ */
+type AngularContentSdkComponent = Type<unknown> | AngularModule;
+/**
+ * The Angular component map type: maps Sitecore rendering names to standalone component types or SXA variant groups.
+ * @public
+ */
+type ComponentMap = Map<string, AngularContentSdkComponent>;
+
+/**
+ * Injection token for the Sitecore component map.
+ * Provide this at the application level via `provideSitecoreAngular` or
+ * directly as `{ provide: SITECORE_COMPONENT_MAP, useValue: yourMap }`.
+ * @public
+ */
+declare const SITECORE_COMPONENT_MAP: InjectionToken<ComponentMap>;
+
+/**
+ * Result of resolving a component for a rendering definition.
+ */
+interface ComponentForRendering {
+    component: Type<unknown> | null;
+    isEmpty: boolean;
+}
+/**
+ * Merged props passed to each child component rendered by a placeholder.
+ * Matches React `getChildComponentProps`: merged `fields` / `params` props plus raw `rendering`.
+ */
+interface ChildComponentProps {
+    fields: {
+        [key: string]: unknown;
+    };
+    params: {
+        [key: string]: string;
+    };
+    rendering: ComponentRendering;
+}
+/**
+ * Get the renderings for the specified placeholder from the rendering layout data.
+ * Includes dynamic placeholder handling aligned with React's implementation.
+ * @param {ComponentRendering | RouteData} rendering - rendering data
+ * @param {string} name - placeholder name
+ * @param {boolean} isEditing - whether editing mode is active
+ * @returns {ComponentRendering[]} Child renderings for the placeholder.
+ */
+declare const getPlaceholderRenderings: (rendering: ComponentRendering | RouteData, name: string, isEditing: boolean) => ComponentRendering[];
+/**
+ * Extra inputs to set on each dynamically rendered component (in addition to `fields`, `params`, and `rendering`).
+ * Keys are Angular `input()` names on the host component.
+ * @public
+ */
+type PassThroughProps = Readonly<Record<string, unknown>>;
+/**
+ * Get SXA specific params from Sitecore rendering params.
+ * @param {ComponentRendering} rendering - Rendering object.
+ * @returns {{ Styles: string } | undefined} Converted SXA params, or `undefined` when none apply.
+ */
+declare const getSXAParams: (rendering: ComponentRendering) => {
+    Styles: string;
+} | undefined;
+/**
+ * Merge placeholder-level fields/params with per-component fields/params.
+ * @param {{ [key: string]: unknown } | undefined} placeholderFields - Placeholder-level fields.
+ * @param {{ [key: string]: string } | undefined} placeholderParams - Placeholder-level params.
+ * @param {ComponentRendering} componentRendering - The component rendering data.
+ * @returns {ChildComponentProps} Merged child component props.
+ */
+declare function getChildComponentProps(placeholderFields: {
+    [key: string]: unknown;
+} | undefined, placeholderParams: {
+    [key: string]: string;
+} | undefined, componentRendering: ComponentRendering): ChildComponentProps;
+/**
+ * Resolve a component type for a rendering definition.
+ * Handles hidden renderings, missing components, variant selection, and map lookup.
+ * FEaaS/BYOC are intentionally not handled; they fall through to missingComponent.
+ * @param {ComponentRendering} renderingDefinition - The rendering to resolve.
+ * @param {string} placeholderName - Current placeholder name (for logging).
+ * @param {ComponentMap | undefined} componentMap - The app component map.
+ * @param {Type<unknown> | undefined} hiddenRenderingComponent - Optional override for hidden renderings.
+ * @param {Type<unknown> | undefined} missingComponentComponent - Optional override for missing/unknown components.
+ * @returns {ComponentForRendering} Resolved component info.
+ */
+declare const resolveComponentForRendering: (renderingDefinition: ComponentRendering, placeholderName: string, componentMap: ComponentMap, hiddenRenderingComponent?: Type<unknown>, missingComponentComponent?: Type<unknown>) => ComponentForRendering;
+
+/**
+ * Angular placeholder component. Renders components from layout data for a given placeholder name.
+ *
+ * Usage:
+ * ```html
+ * <sc-placeholder name="headless-main" [rendering]="route"></sc-placeholder>
+ * ```
+ *
+ * Optional `[passThroughProps]` sets extra `input()` values on each child (merged after `fields`, `params`, and `rendering`).
+ * @public
+ */
+declare class ScPlaceholderComponent {
+    /** Name of the placeholder to render. */
+    readonly name: i0.InputSignal<string>;
+    /** Rendering or route data containing placeholders. */
+    readonly rendering: i0.InputSignal<RouteData<Record<string, _sitecore_content_sdk_angular.Field<_sitecore_content_sdk_content_layout.GenericFieldValue> | _sitecore_content_sdk_angular.Item | _sitecore_content_sdk_angular.Item[]>> | ComponentRendering<_sitecore_content_sdk_angular.ComponentFields>>;
+    /** Optional placeholder-level fields merged into each child. */
+    readonly fields: i0.InputSignal<{
+        [key: string]: unknown;
+    } | undefined>;
+    /** Optional placeholder-level params merged into each child's `params` input. */
+    readonly params: i0.InputSignal<{
+        [key: string]: string;
+    } | undefined>;
+    /**
+     * Extra inputs to set on each dynamically created component, after the standard `fields`, `params`, and `rendering` inputs.
+     * Keys must match `input()` names on the target components.
+     */
+    readonly passThroughProps: i0.InputSignal<Readonly<Record<string, unknown>>>;
+    /** Override component map (defaults to injected SITECORE_COMPONENT_MAP). */
+    readonly componentMap: i0.InputSignal<ComponentMap | undefined>;
+    /** Override for missing component rendering. */
+    readonly missingComponent: i0.InputSignal<Type<unknown> | undefined>;
+    /** Override for hidden rendering component. */
+    readonly hiddenRenderingComponent: i0.InputSignal<Type<unknown> | undefined>;
+    private readonly context;
+    private readonly contextComponentMap;
+    private readonly injector;
+    private readonly containerRef;
+    private readonly isEditing;
+    constructor();
+    private trySetInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScPlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScPlaceholderComponent, "sc-placeholder", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "rendering": { "alias": "rendering"; "required": true; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "passThroughProps": { "alias": "passThroughProps"; "required": false; "isSignal": true; }; "componentMap": { "alias": "componentMap"; "required": false; "isSignal": true; }; "missingComponent": { "alias": "missingComponent"; "required": false; "isSignal": true; }; "hiddenRenderingComponent": { "alias": "hiddenRenderingComponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Angular wrapper for Sitecore Forms.
+ * Loads form HTML from Edge, executes embedded scripts, and subscribes to form events.
+ *
+ * Usage: register in the component map with the rendering name "Form".
+ * @public
+ */
+declare class ScFormComponent {
+    private formContainerRef;
+    readonly rendering: i0.InputSignal<ComponentRendering<_sitecore_content_sdk_angular.ComponentFields> | undefined>;
+    readonly params: i0.InputSignal<{
+        [key: string]: string;
+    }>;
+    private readonly config;
+    private readonly context;
+    private readonly platformId;
+    private readonly destroyRef;
+    /**
+     * Merges `rendering.params` with the `params` input: the component `params()` values override layout for the same key.
+     */
+    private mergedFormParams;
+    constructor();
+    readonly styles: () => string;
+    readonly renderingId: () => string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScFormComponent, "sc-form", never, { "rendering": { "alias": "rendering"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Default component rendered when a Sitecore rendering has no matching entry in the component map.
+ * @public
+ */
+declare class ScMissingComponentComponent {
+    readonly rendering: i0.InputSignal<ComponentRendering<_sitecore_content_sdk_angular.ComponentFields> | undefined>;
+    readonly fields: i0.InputSignal<{
+        [key: string]: unknown;
+    } | undefined>;
+    readonly params: i0.InputSignal<{
+        [key: string]: string;
+    } | undefined>;
+    readonly componentName: () => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScMissingComponentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScMissingComponentComponent, "sc-missing-component", never, { "rendering": { "alias": "rendering"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Default component rendered for hidden Sitecore renderings.
+ * @public
+ */
+declare class ScHiddenRenderingComponent {
+    readonly rendering: i0.InputSignal<ComponentRendering<_sitecore_content_sdk_angular.ComponentFields> | undefined>;
+    readonly fields: i0.InputSignal<{
+        [key: string]: unknown;
+    } | undefined>;
+    readonly params: i0.InputSignal<{
+        [key: string]: string;
+    } | undefined>;
+    readonly styles: {
+        background: string;
+        minHeight: string;
+        border: string;
+        padding: string;
+        opacity: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScHiddenRenderingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScHiddenRenderingComponent, "sc-hidden-rendering", never, { "rendering": { "alias": "rendering"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a Sitecore text field value into the host element's text content.
+ * For simple string/number fields in published mode.
+ *
+ * Usage:
+ * ```html
+ * <h1 [scText]="fields.Title"></h1>
+ * <span [scText]="fields.Subtitle" scTextEncode="false"></span>
+ * ```
+ * @public
+ */
+declare class ScTextDirective {
+    /** The Sitecore text field. */
+    readonly scText: i0.InputSignal<TextField>;
+    /** Whether to HTML-encode the value (default: true). When false, uses innerHTML. */
+    readonly scTextEncode: i0.InputSignal<boolean>;
+    private readonly el;
+    private readonly renderer;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScTextDirective, "[scText]", never, { "scText": { "alias": "scText"; "required": true; "isSignal": true; }; "scTextEncode": { "alias": "scTextEncode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Image field value shape.
+ */
+interface ImageFieldValue {
+    [attributeName: string]: unknown;
+    src?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Image field shape (with optional value wrapper).
+ */
+interface ImageField {
+    value?: ImageFieldValue;
+    metadata?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Renders a Sitecore image field onto a host `<img>` element.
+ * Sets `src`, `alt`, and other attributes from the field data.
+ *
+ * Usage:
+ * ```html
+ * <img [scImage]="fields.Image" />
+ * ```
+ * @public
+ */
+declare class ScImageDirective {
+    /** The Sitecore image field. */
+    readonly scImage: i0.InputSignal<ImageFieldValue | ImageField | undefined>;
+    /** Optional image params for media URL transformation. */
+    readonly imageParams: i0.InputSignal<{
+        [paramName: string]: string | number;
+    } | undefined>;
+    /** Optional media URL prefix regexp. */
+    readonly mediaUrlPrefix: i0.InputSignal<RegExp | undefined>;
+    private readonly el;
+    private readonly renderer;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScImageDirective, "img[scImage]", never, { "scImage": { "alias": "scImage"; "required": true; "isSignal": true; }; "imageParams": { "alias": "imageParams"; "required": false; "isSignal": true; }; "mediaUrlPrefix": { "alias": "mediaUrlPrefix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a Sitecore link field onto a host `<a>` element.
+ * Sets `href`, `title`, `target`, `class`, and text content from the field data.
+ *
+ * Locale-awareness: when a configured locale list is provided via `sitecore.config`,
+ * internal hrefs are prefixed with the current URL locale (read from
+ * {@link SitecoreContextService}). Hrefs that already contain a configured-locale segment
+ * are written as-is, which respects author-intent cross-locale links and keeps the
+ * directive idempotent under repeated change detection.
+ *
+ * Usage:
+ * ```html
+ * <a [scLink]="fields.Link">Optional child content</a>
+ * ```
+ * @public
+ */
+declare class ScLinkDirective {
+    /** The Sitecore link field. */
+    readonly scLink: i0.InputSignal<LinkField | LinkFieldValue>;
+    /** Whether to show link text alongside existing child content. */
+    readonly preferTextFromField: i0.InputSignal<boolean>;
+    protected readonly el: ElementRef<any>;
+    private readonly renderer;
+    private readonly context;
+    private readonly locales;
+    private readonly originalClass;
+    private readonly originalTitle;
+    private readonly originalTarget;
+    private readonly originalRel;
+    constructor();
+    /**
+     * Returns a copy of the link with `href` prefixed by the current URL locale when applicable.
+     * Internal hrefs are prefixed only when:
+     *   1. There is a current URL locale (page itself has a locale prefix), and
+     *   2. The href does not already start with a configured locale segment.
+     * External, fragment-only, and locale-prefixed hrefs are returned unchanged.
+     * @param {LinkFieldValue} link - Resolved link value from layout data.
+     * @returns {LinkFieldValue} Link value with locale-aware href.
+     */
+    private localizeLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScLinkDirective, "a[scLink]", never, { "scLink": { "alias": "scLink"; "required": true; "isSignal": true; }; "preferTextFromField": { "alias": "preferTextFromField"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a Sitecore link field onto a host `<a>` and calls `Router.navigateByUrl` on click
+ * for in-app paths only. Clicks are left to the browser when `href` is missing/empty, when
+ * `target="_blank"`, or when `href` uses http(s), mailto, tel, sms, javascript, data, ftp,
+ * or protocol-relative (`//`) URLs.
+ *
+ * Usage:
+ * ```html
+ * <a [scRouterLink]="fields.Link">Optional child content</a>
+ * ```
+ * @public
+ */
+declare class ScRouterLinkDirective extends ScLinkDirective {
+    /**
+     * Sitecore link field; host attribute `[scRouterLink]` maps to the base {@link ScLinkDirective.scLink} input.
+     */
+    readonly scLink: i0.InputSignal<LinkField | LinkFieldValue>;
+    private readonly router;
+    onClick(event: MouseEvent): void;
+    /**
+     * Returns true when the browser should handle navigation (no in-app Router navigation).
+     * @param {string | null} hrefAttr - Raw `href` attribute from the anchor.
+     * @param {string | null} targetAttr - Raw `target` attribute from the anchor.
+     * @returns {boolean} Whether to skip `Router.navigateByUrl`.
+     */
+    private shouldDeferNavigation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScRouterLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScRouterLinkDirective, "a[scRouterLink]", never, { "scLink": { "alias": "scRouterLink"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a Sitecore rich text field value as innerHTML of the host element.
+ * Content is marked trusted for Angular sanitization (typical for CMS-authored HTML).
+ *
+ * Usage:
+ * ```html
+ * <div [scRichText]="fields.Content"></div>
+ * ```
+ * @public
+ */
+declare class ScRichTextDirective {
+    /** The Sitecore rich text field. */
+    readonly scRichText: i0.InputSignal<TextField>;
+    private readonly el;
+    private readonly renderer;
+    private readonly sanitizer;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScRichTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScRichTextDirective, "[scRichText]", never, { "scRichText": { "alias": "scRichText"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const _coreVersionMarker: i0.Version;
+declare const _routerTokenMarker: typeof Router;
+
+export { ClientLoaderDataService, ClientPreLoaderDataService, DEFAULT_EXPORT_NAME, FETCH_DATA_ENDPOINT, LOADER_DATA_ENDPOINT, LOADER_ID, LOADER_REGISTRY, LoaderHttpError, LocaleUrlSerializer, NotFoundNavigationError, SERVER_LOADER_RUNNER, SITECORE_CLIENT_TOKEN, SITECORE_COMPONENT_MAP, SITECORE_CONFIG_TOKEN, ScFormComponent, ScHiddenRenderingComponent, ScImageDirective, ScLinkDirective, ScMissingComponentComponent, ScPlaceholderComponent, ScRichTextDirective, ScRouterLinkDirective, ScTextDirective, ServerLoaderRunner, SitecoreContextService, SitecoreTranslateLoader, _coreVersionMarker, _routerTokenMarker, applyRedirect, collectSitecoreTagsFromEdgeRevalidateRequestBody, createCacheAdminMiddleware, createExpressDataMiddleware, createLoaderCache, createLoaderDataServiceMiddleware, createSitecoreRevalidateMiddleware, defineConfig, extractSitecoreEdgeContentId, getChildComponentProps, getPlaceholderRenderings, getSXAParams, handleNavigationError, loaderResolver, provideLoaderRegistry, provideServerLoaderRunner, provideSitecoreAngular, resolveComponentForRendering, resolveConfiguredRevalidateSecret, resolveSitecorePage, scLocaleMatcher, splitLocaleFromPath };
+export type { AngularCSDKAppInit, AngularContentSdkComponent, AngularSitecoreConfig, AngularSitecoreConfigInput, CacheAdminMiddlewareOptions, ChildComponentProps, CollectSitecoreTagsFromEdgeBodyOptions, ComponentForRendering, ComponentMap, DataHandlerConfig, ExpressDataHandlerOptions, ExpressMiddleware, ExpressNextFunction, ExpressRequest, ExpressResponse, GlobalLoaderCacheConfig, LoaderCacheConfig, LoaderContext, LoaderDataRequest, LoaderDataResult, LoaderFn, LoaderId, LoaderIdMap, LoaderRegistry, LocaleExtractionResult, PassThroughProps, PerRouteLoaderCacheConfig, ServerLoaderRunnerPort, SitecoreEdgeRevalidateRequestBody, SitecoreEdgeRevalidateUpdate, SitecoreRevalidateMiddlewareOptions };
+//# sourceMappingURL=sitecore-content-sdk-angular.d.ts.map