@o3r/transloco 0.0.0 → 14.5.0-prerelease.1

package/types/o3r-transloco.d.ts

@@ -0,0 +1,804 @@
+import { Translation, OtterMessageContent, ConnectContentMessage, RequestMessagesContentMessage, MessageDataTypes, DevtoolsCommonOptions, ContextualizationDevtoolsCommonOptions, DevtoolsServiceInterface, SetStateActionPayload, Serializer } from '@o3r/core';
+export { Translation } from '@o3r/core';
+import * as i0 from '@angular/core';
+import { OnDestroy, EnvironmentProviders, InjectionToken, ModuleWithProviders, FactoryProvider, OnInit, OnChanges, SimpleChanges, PipeTransform, ChangeDetectorRef, DestroyRef } from '@angular/core';
+import * as _ngrx_store from '@ngrx/store';
+import { ActionReducer, Action, ReducerTypes, ActionCreator } from '@ngrx/store';
+import { DynamicContentService } from '@o3r/dynamic-content';
+import { LoggerService } from '@o3r/logger';
+import { TranslocoLoader, Translation as Translation$1, TranslocoService, TranslocoDirective, TranslocoPipe } from '@jsverse/transloco';
+import { Observable, Subject, Subscription } from 'rxjs';
+import { CurrencyPipe, DatePipe, DecimalPipe } from '@angular/common';
+
+/**
+ * Decorator to pass localization url
+ * @param url
+ */
+declare function Localization(url: string): (target: any, key: string) => void;
+
+/** Object mapping of a localized string */
+interface JSONLocalization {
+    /** The key of the localized string. */
+    key: string;
+    /** The description of the key used to give some context to the translators. */
+    description: string;
+    /** True means that the key will be mapped to a dictionary in the CMS. */
+    dictionary: boolean;
+    /** True means that the value has to be overriden in the CMS. */
+    referenceData: boolean;
+    /** Tags used to filter/categorize localization strings */
+    tags?: string[];
+    /** The default value for EN language. It is mandatory if dictionary is set to false. */
+    value?: string;
+    /** Reference to another key. */
+    ref?: string;
+}
+/** Localization Metadata file structure */
+type LocalizationMetadata = JSONLocalization[];
+
+/**
+ * Describes configuration for LocalizationModule
+ */
+interface LocalizationConfiguration {
+    /** List of available languages */
+    supportedLocales: string[];
+    /** Application display language */
+    language?: string;
+    /** Url to fetch translation bundles from */
+    endPointUrl: string;
+    /** Prefix endPoinrUrl with dynamicContentPath provided by DynamicContentPath */
+    useDynamicContent: boolean;
+    /** List of RTL language codes */
+    rtlLanguages: string[];
+    /**
+     * Fallback language map of resource in case translation in language does not exist.
+     * translate to unsupported language will try to map to supportedLocales from below property.
+     * @example Mapping of fallback languages
+     * ```typescript
+     * {
+     *   supportedLocales: ['en-GB', 'en-US', 'fr-FR'],
+     *   fallbackLocalesMap: {'en-CA': 'en-US', 'de': 'fr-FR'}
+     * }
+     * // translate to en-CA -> fallback to en-US, translate to de-DE -> fallback to fr-FR,
+     * // translate to en-NZ -> fallback to en-GB, translate to en -> fallback to en-GB.
+     * ```
+     */
+    fallbackLocalesMap?: {
+        [supportedLocale: string]: string;
+    };
+    /** Fallback language of resource in case translation in language does not exist */
+    fallbackLanguage: string;
+    /** Path relative to published folder where webpack will copy translation bundles */
+    bundlesOutputPath: string;
+    /** Debug mode switch */
+    debugMode: boolean;
+    /** Query parameters for fetching the localization resources */
+    queryParams?: {
+        [key: string]: string;
+    };
+    /** Fetch options object as per https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters */
+    fetchOptions?: RequestInit;
+    /** Enable the ability to switch the translations on and off at runtime. */
+    enableTranslationDeactivation: boolean;
+    /**
+     * Merge the translations from DynamicContentPath with the local translations
+     * Warning: Enable this option will download two localization bundles and can delay the display of the text on application first page
+     * @default false
+     */
+    mergeWithLocalTranslations: boolean;
+}
+/**
+ * Default configuration for LocalizationModule
+ */
+declare const DEFAULT_LOCALIZATION_CONFIGURATION: Readonly<LocalizationConfiguration>;
+
+/**
+ * Translatable item
+ */
+interface Translatable<T extends Translation> {
+    /**
+     * translations map
+     */
+    translations: T;
+}
+
+/**
+ * Configuration options for the Localization Devtools service
+ */
+interface LocalizationDevtoolsServiceOptions extends DevtoolsCommonOptions, ContextualizationDevtoolsCommonOptions {
+    /** Path to the localization metadata file */
+    metadataFilePath: string;
+}
+/** Localizations message content */
+interface LocalizationsContentMessage extends OtterMessageContent<'localizations'> {
+    /** Localizations metadata */
+    localizations: LocalizationMetadata;
+}
+/** Languages message content */
+interface LanguagesContentMessage extends OtterMessageContent<'languages'> {
+    /** Languages available */
+    languages: string[];
+}
+/** Switch languages message content */
+interface SwitchLanguageContentMessage extends OtterMessageContent<'switchLanguage'> {
+    /** Language */
+    language: string;
+}
+/** Display localization key message content */
+interface DisplayLocalizationKeysContentMessage extends OtterMessageContent<'displayLocalizationKeys'> {
+    /** Toggle the display of the localization keys */
+    toggle?: boolean;
+}
+/** Update localization message content */
+interface UpdateLocalizationContentMessage extends OtterMessageContent<'updateLocalization'> {
+    /** Localization key */
+    key: string;
+    /** Localization value */
+    value: string;
+    /** Lang */
+    lang?: string;
+}
+/** Reload localization Keys message content */
+interface ReloadLocalizationKeysContentMessage extends OtterMessageContent<'reloadLocalizationKeys'> {
+    /** Lang */
+    lang?: string;
+}
+/** Is translation deactivation enabled message content */
+interface IsTranslationDeactivationEnabledContentMessage extends OtterMessageContent<'isTranslationDeactivationEnabled'> {
+    /** Whether translation deactivation is enabled */
+    enabled: boolean;
+}
+/** Get translation values message content */
+interface GetTranslationValuesContentMessage extends OtterMessageContent<'getTranslationValuesContentMessage'> {
+    /** Translation key-value pairs */
+    translations: {
+        [localizationKey: string]: string;
+    };
+}
+/** Union type of all localization message contents */
+type LocalizationMessageContents = LanguagesContentMessage | ReloadLocalizationKeysContentMessage | SwitchLanguageContentMessage | LocalizationsContentMessage | DisplayLocalizationKeysContentMessage | UpdateLocalizationContentMessage | IsTranslationDeactivationEnabledContentMessage | GetTranslationValuesContentMessage;
+/** List of possible DataTypes for Localization messages */
+type LocalizationMessageDataTypes = MessageDataTypes<LocalizationMessageContents>;
+/** List of all messages for Localization purpose */
+type AvailableLocalizationMessageContents = LocalizationMessageContents | ConnectContentMessage | RequestMessagesContentMessage<LocalizationMessageDataTypes>;
+/**
+ * Contextualization devtools exposed for localization in CMS integration
+ */
+interface LocalizationContextualizationDevtools {
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled(): boolean | Promise<boolean>;
+    /**
+     * Show localization keys
+     * @param value value enforced by the DevTools extension
+     */
+    showLocalizationKeys: (value?: boolean) => void | Promise<void>;
+    /**
+     * Returns the current language
+     */
+    getCurrentLanguage: () => string | Promise<string>;
+    /**
+     * Switch the current language to the specified value
+     * @param language new language to switch to
+     */
+    switchLanguage: (language: string) => Promise<{
+        previous: string;
+        requested: string;
+        current: string;
+    }>;
+    /**
+     * Set up a listener on language change
+     * @param fn called when the language is changed in the app
+     * @returns Object with unsubscribe() method to prevent memory leaks
+     */
+    onLanguageChange: (fn: (language: string) => any) => {
+        unsubscribe: () => void;
+    };
+    /**
+     * Clear all language change listeners
+     */
+    clearLanguageChangeListeners: () => void;
+    /**
+     * Updates the specified localization key/values for the current language
+     * @param keyValues key/values to update
+     * @param language if not provided, the current language value
+     */
+    updateLocalizationKeys: (keyValues: {
+        [key: string]: string;
+    }, language?: string) => void | Promise<void>;
+    /**
+     * Reload a language from the language file
+     * @see https://github.com/jsverse/transloco
+     * @param language language to reload
+     */
+    reloadLocalizationKeys: (language?: string) => Promise<void>;
+}
+
+/**
+ * Service that provides core localization devtools functionality
+ */
+declare class OtterLocalizationDevtools implements OnDestroy {
+    private readonly localizationService;
+    private readonly translateTranspiler;
+    private readonly appRef;
+    private readonly languageChangeSubscriptions;
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled(): boolean;
+    /**
+     * Show localization keys
+     * @param value value enforced by the DevTools extension
+     */
+    showLocalizationKeys(value?: boolean): void;
+    /**
+     * Returns the current language
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Set up a listener on language change
+     * @param fn called when the language is changed in the app
+     * @returns Object with unsubscribe() method to prevent memory leaks
+     */
+    onLanguageChange(fn: (language: string) => any): {
+        unsubscribe: () => void;
+    };
+    /**
+     * Clear all language change listeners
+     */
+    clearLanguageChangeListeners(): void;
+    /**
+     * Cleanup subscriptions when service is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Switch the current language to the specified value
+     * @param language new language to switch to
+     */
+    switchLanguage(language: string | undefined): Promise<void>;
+    /**
+     * Updates the specified localization key/values for the current language.
+     *
+     * Recommendation: To be used with a small number of keys to update to avoid performance issues.
+     * @param keyValues key/values to update
+     * @param language if not provided, the current language value
+     */
+    updateLocalizationKeys(keyValues: {
+        [key: string]: string;
+    }, language?: string): void | Promise<void>;
+    /**
+     * Reload a language from the language file
+     * @param language language to reload
+     */
+    reloadLocalizationKeys(language?: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OtterLocalizationDevtools, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OtterLocalizationDevtools>;
+}
+
+/**
+ * Service that exposes localization devtools functionality via the browser console
+ */
+declare class LocalizationDevtoolsConsoleService implements DevtoolsServiceInterface, LocalizationContextualizationDevtools {
+    /** Name of the Window property to access to the devtools */
+    static readonly windowModuleName = "localization";
+    private readonly localizationDevtools;
+    private readonly options;
+    constructor();
+    /** @inheritDoc */
+    activate(): void;
+    /**
+     * @inheritdoc
+     */
+    isTranslationDeactivationEnabled(): boolean | Promise<boolean>;
+    /**
+     * @inheritdoc
+     */
+    showLocalizationKeys(value?: boolean): void | Promise<void>;
+    /**
+     * @inheritdoc
+     */
+    getCurrentLanguage(): string | Promise<string>;
+    /**
+     * @inheritdoc
+     */
+    switchLanguage(language: string): Promise<{
+        previous: string;
+        requested: string;
+        current: string;
+    }>;
+    /**
+     * @inheritdoc
+     */
+    onLanguageChange(fn: (language: string) => any): {
+        unsubscribe: () => void;
+    };
+    /**
+     * @inheritdoc
+     */
+    clearLanguageChangeListeners(): void;
+    /**
+     * @inheritdoc
+     */
+    updateLocalizationKeys(keyValues: {
+        [key: string]: string;
+    }, language?: string): void | Promise<void>;
+    /**
+     * @inheritdoc
+     */
+    reloadLocalizationKeys(language?: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationDevtoolsConsoleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationDevtoolsConsoleService>;
+}
+
+/**
+ * Service that handles localization devtools messages communication
+ */
+declare class LocalizationDevtoolsMessageService {
+    private readonly logger;
+    private readonly localizationDevTools;
+    private readonly localizationService;
+    private readonly options;
+    private readonly sendMessage;
+    private readonly destroyRef;
+    constructor();
+    private sendLocalizationsMetadata;
+    /**
+     * Function to trigger a re-send a requested messages to the Otter Chrome DevTools extension
+     * @param only restricted list of messages to re-send
+     */
+    private handleReEmitRequest;
+    /**
+     * Function to handle the incoming messages from Otter Chrome DevTools extension
+     * @param message Message coming from the Otter Chrome DevTools extension
+     */
+    private handleEvents;
+    /**
+     * Function to connect the plugin to the Otter Chrome DevTools extension
+     */
+    private connectPlugin;
+    /** @inheritDoc */
+    activate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationDevtoolsMessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationDevtoolsMessageService>;
+}
+
+/**
+ * Provide localization devtools functionality for the application.
+ * This is the recommended way to set up localization devtools in standalone applications.
+ * @param options Optional partial localization devtools configuration to override defaults. Can be a configuration object or a factory function.
+ * @example Load localization with automatic activation at bootstrap
+ * ```typescript
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideLocalizationDevtools({ isActivatedOnBootstrap: true })
+ *   ]
+ * });
+ * ```
+ */
+declare function provideLocalizationDevtools(options?: Partial<LocalizationDevtoolsServiceOptions>): EnvironmentProviders;
+
+/**
+ * Default configuration options for the Otter Localization Devtools
+ */
+declare const OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS: Readonly<LocalizationDevtoolsServiceOptions>;
+/**
+ * Injection token for Otter Localization Devtools configuration options
+ */
+declare const OTTER_LOCALIZATION_DEVTOOLS_OPTIONS: InjectionToken<LocalizationDevtoolsServiceOptions>;
+
+/**
+ * LocalizationOverride store state
+ */
+interface LocalizationOverrideState {
+    /** Mapping of initial localization keys to the one they are replaced with */
+    localizationOverrides: Record<string, string>;
+}
+/**
+ * Name of the LocalizationOverride Store
+ */
+declare const LOCALIZATION_OVERRIDE_STORE_NAME = "localizationOverride";
+/**
+ * LocalizationOverride Store Interface
+ */
+interface LocalizationOverrideStore {
+    /** LocalizationOverride state */
+    [LOCALIZATION_OVERRIDE_STORE_NAME]: LocalizationOverrideState;
+}
+
+/**
+ * Clear all overrides and fill the store with the payload
+ */
+declare const setLocalizationOverride: _ngrx_store.ActionCreator<"[LocalizationOverride] set", (props: SetStateActionPayload<LocalizationOverrideState>) => SetStateActionPayload<LocalizationOverrideState> & _ngrx_store.Action<"[LocalizationOverride] set">>;
+
+/** Token of the LocalizationOverride reducer */
+declare const LOCALIZATION_OVERRIDE_REDUCER_TOKEN: InjectionToken<ActionReducer<LocalizationOverrideState, Action<string>>>;
+/** Provide default reducer for LocalizationOverride store */
+declare function getDefaultLocalizationOverrideReducer(): ActionReducer<LocalizationOverrideState, Action<string>>;
+/**
+ * NgModule for localization override store.
+ */
+declare class LocalizationOverrideStoreModule {
+    static forRoot<T extends LocalizationOverrideState>(reducerFactory: () => ActionReducer<T, Action>): ModuleWithProviders<LocalizationOverrideStoreModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationOverrideStoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LocalizationOverrideStoreModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LocalizationOverrideStoreModule>;
+}
+
+/**
+ * LocalizationOverride Store initial value
+ */
+declare const localizationOverrideInitialState: LocalizationOverrideState;
+/**
+ *  List of basic actions for LocalizationOverride Store
+ */
+declare const localizationOverrideReducerFeatures: ReducerTypes<LocalizationOverrideState, ActionCreator[]>[];
+/**
+ * LocalizationOverride Store reducer
+ */
+declare const localizationOverrideReducer: _ngrx_store.ActionReducer<LocalizationOverrideState, _ngrx_store.Action<string>>;
+
+/** Select LocalizationOverride State */
+declare const selectLocalizationOverrideState: _ngrx_store.MemoizedSelector<object, LocalizationOverrideState, _ngrx_store.DefaultProjectorFn<LocalizationOverrideState>>;
+/** Select all localization override map */
+declare const selectLocalizationOverride: _ngrx_store.MemoizedSelector<object, Record<string, string>, (s1: LocalizationOverrideState) => Record<string, string>>;
+
+/**
+ * Deserializer for the LocalizationOverride store storage
+ * @param rawObject
+ */
+declare const localizationOverrideStorageDeserializer: (rawObject: any) => any;
+/** Serializer/Deserializer configuration for the LocalizationOverride store sync */
+declare const localizationOverrideStorageSync: Serializer<LocalizationOverrideState>;
+
+/**
+ * Formats a debug key string combining the translation key and its value.
+ * Used across the localization service, pipe, and directive when debugMode is enabled.
+ * @param key The translation key
+ * @param value The translated value
+ */
+declare function getDebugKey(key: string, value: string): string;
+
+/**
+ * This class is responsible for loading translation bundles from remote or local endpoints depending on the LocalizationConfiguration.
+ * Fallback mechanism ensures that if a bundle in some language cannot be fetched remotely
+ * we try to fetch the same language bundle locally (bundles stored inside the application)
+ * and finally load the fallback language bundle (if all previous fetches failed)
+ */
+declare class TranslationsLoader implements TranslocoLoader {
+    private readonly localizationConfiguration;
+    private readonly logger?;
+    private readonly dynamicContentService?;
+    /**
+     * Download a language bundle file
+     * @param  url Url to the bundle file
+     */
+    private downloadLanguageBundle$;
+    /**
+     * @inheritdoc
+     */
+    getTranslation(lang: string): Observable<Translation$1>;
+    /**
+     *
+     *Fetches localization bundles from published folder (internal to application)
+     *
+     *1. try to load lang from local
+     *2. if 1 fails try to load fallback lang but only if it's different from lang in 1
+     * @param lang - language of the bundle
+     * @param fallbackLanguage - fallback language in case bundle in language not found
+     */
+    getTranslationFromLocal(lang: string, fallbackLanguage: string): Observable<Translation$1>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationsLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationsLoader>;
+}
+
+/**
+ * Creates a loader of translations bundles based on the configuration
+ * (endPointUrl and language determine which bundle we load and where do we fetch it from)
+ * @param localizationConfiguration
+ * @param logger service to handle the log of warning and errors
+ * @param dynamicContentService (optional)
+ */
+declare function createTranslateLoader(localizationConfiguration: LocalizationConfiguration, logger?: LoggerService, dynamicContentService?: DynamicContentService): TranslationsLoader;
+/**
+ * TranslocoLoader provider, using framework's TranslationsLoader class
+ */
+declare const translateLoaderProvider: Readonly<FactoryProvider>;
+
+/**
+ * Service which is wrapping the configuration logic of TranslocoService from JSVerse Transloco.
+ * Any application willing to use localization just needs to inject LocalizationService
+ * in the root component and call its configure() method.
+ */
+declare class LocalizationService {
+    private readonly translateService;
+    private readonly logger;
+    private readonly configuration;
+    private readonly store;
+    private readonly localeSplitIdentifier;
+    /**
+     * Internal signal that we use to track changes between keys only and translation mode
+     */
+    private readonly _showKeys;
+    /**
+     * Map of localization keys to replace a key to another
+     */
+    private readonly keyMapping$?;
+    /**
+     * _showKeys exposed as an Observable
+     */
+    readonly showKeys$: Observable<boolean>;
+    /**
+     * Return the current value of debug show/hide translation keys.
+     */
+    readonly showKeys: i0.Signal<boolean>;
+    constructor();
+    /**
+     * This will handle the fallback language hierarchy to find out fallback language.
+     * supportedLocales language has highest priority, next priority goes to fallbackLocalesMap and default would be
+     * fallbackLanguage.
+     * @param language Selected language.
+     * @returns selected language if supported, fallback language otherwise.
+     */
+    private checkFallbackLocalesMap;
+    /**
+     * This function checks if fallback language can be provided from fallbackLocalesMap.
+     * supportedLocales: ['en-GB', 'en-US', 'fr-FR'], fallbackLocalesMap: {'en-CA': 'en-US', 'de': 'fr-FR'}
+     * translate to en-CA -> fallback to en-US, translate to de-DE -> fallback to fr-FR
+     * translate to en-NZ -> fallback to en-GB
+     * @param language Selected language.
+     * @returns Fallback language if available, undefined otherwise.
+     */
+    private getFallbackMapLangCode;
+    /**
+     * This function checks if closest supported language available incase of selected language is not
+     * supported language.
+     * supportedLocales: ['en-GB', 'en-US', 'fr-FR']
+     * translate to en-CA -> fallback to en-GB
+     * @param language Selected language.
+     * @returns Closest supported language if available, undefined otherwise.
+     */
+    private getFirstClosestSupportedLanguageCode;
+    /**
+     * Returns a stream of translated values of a key which updates whenever the language changes.
+     * @param translationKey Key to translate
+     * @param interpolateParams Object to use in translation binding
+     * @returns A stream of the translated key
+     */
+    private getTranslationStream;
+    /**
+     * Configures TranslocoService and registers locales. This method is called from the application level.
+     */
+    configure(): Promise<void>;
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled(): boolean;
+    /**
+     * Wrapper to call the TranslocoService method getAvailableLangs().
+     */
+    getLanguages(): string[];
+    /**
+     * Wrapper to call the TranslocoService method setActiveLang(language).
+     * @param language
+     */
+    useLanguage(language: string): Observable<any>;
+    /**
+     * Wrapper to get the TranslocoService getActiveLang.
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Get the instance of the TranslocoService used by LocalizationService.
+     */
+    getTranslateService(): TranslocoService;
+    /**
+     * Toggle the ShowKeys mode between active and inactive.
+     * @param value if specified, set the ShowKeys mode to value. If not specified, toggle the ShowKeys mode.
+     */
+    toggleShowKeys(value?: boolean): void;
+    /**
+     * Get an observable of translation key after global mapping
+     * @param requestedKey Original translation key
+     */
+    getKey(requestedKey: string): Observable<any>;
+    /**
+     * Returns a stream of translated values of a key which updates whenever the language changes.
+     * @param key Key to translate
+     * @param interpolateParams Object to use in translation binding
+     * @returns A stream of the translated key
+     */
+    translate(key: string, interpolateParams?: object): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationService>;
+}
+
+/**
+ * creates LocalizationConfiguration, which is used if the application
+ * @param configuration Localization configuration
+ */
+declare function createLocalizationConfiguration(configuration?: Partial<LocalizationConfiguration>): LocalizationConfiguration;
+/**
+ * Factory to inject the LOCALE_ID token with the current language into Angular context
+ * @param localizationService Localization service
+ */
+declare function localeIdNgBridge(localizationService: LocalizationService): string;
+/** Custom Localization Configuration Token to override default localization configuration */
+declare const CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN: InjectionToken<Partial<LocalizationConfiguration>>;
+/**
+ * Provide localization services and configuration for the application.
+ * This is the recommended way to set up localization in standalone applications.
+ * @param configuration Optional partial localization configuration to override defaults. Can be a configuration object or a factory function.
+ * @example Override of default and supported languages override at application bootstrap
+ * ```typescript
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideLocalization({ language: 'en-US', supportedLocales: ['en-US', 'fr-FR'] })
+ *   ]
+ * });
+ * ```
+ */
+declare function provideLocalization(configuration?: Partial<LocalizationConfiguration> | (() => Partial<LocalizationConfiguration>)): EnvironmentProviders;
+
+/** Localization Configuration Token */
+declare const LOCALIZATION_CONFIGURATION_TOKEN: InjectionToken<LocalizationConfiguration>;
+
+/**
+ * TranslocoDirective class adding debug functionality.
+ *
+ * Extends the TranslocoDirective from Transloco to add:
+ * - Key mapping via LocalizationService (override store)
+ * - Show keys mode (display raw keys instead of translations)
+ * - Debug mode (display key alongside translation)
+ *
+ * For the structural strategy (`*transloco`), the debug/showKeys behavior is handled
+ * by overriding `getTranslateFn`.
+ *
+ * For the attribute strategy (`[transloco]="key"`), the parent's private `attributeStrategy()`
+ * sets `innerText` directly. Since we cannot override this private method, we apply
+ * debug/showKeys transformations by overwriting `innerText` immediately after calling
+ * `super.ngOnInit()` and `super.ngOnChanges()`, in the same call stack.
+ */
+declare class LocalizationTranslateDirective extends TranslocoDirective implements OnInit, OnChanges {
+    private readonly localizationService;
+    private readonly localizationConfig;
+    private readonly changeDetectorRef;
+    private readonly hostElement;
+    private readonly hostRenderer;
+    private readonly isAttributeStrategy;
+    private readonly o3rDestroyRef;
+    /**
+     * Should we display keys instead of translations
+     */
+    private showKeys;
+    /**
+     * Subject to emit translation key changes
+     */
+    private readonly translocoSubject;
+    /** @inheritdoc */
+    set transloco(key: string);
+    constructor();
+    /**
+     * For the attribute strategy, overwrites `innerText` with the debug/showKeys value
+     * immediately after the parent has set it.
+     */
+    private applyAttributeDebug;
+    /**
+     * Override getTranslateFn to plug debug/showKeys for the structural strategy.
+     * @param lang Current language
+     * @param prefix Scope prefix
+     */
+    protected getTranslateFn(lang: string, prefix: string | undefined): (key: string, params?: Record<string, unknown>) => any;
+    /** @inheritdoc */
+    ngOnInit(): void;
+    /** @inheritdoc */
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationTranslateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LocalizationTranslateDirective, "[transloco]", never, { "transloco": { "alias": "transloco"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * TranslocoPipe class adding debug functionality
+ */
+declare class O3rLocalizationTranslatePipe extends TranslocoPipe implements PipeTransform {
+    /** Localization service instance */
+    protected readonly localizationService: LocalizationService;
+    /** Change detector service instance */
+    protected readonly changeDetector: ChangeDetectorRef;
+    /** Localization config token */
+    protected readonly localizationConfig: LocalizationConfiguration;
+    /** Destroy reference */
+    protected readonly destroyRef: DestroyRef;
+    /**
+     * Should we display keys instead of translations
+     */
+    protected showKeys: boolean;
+    /**
+     * Subject to emit translation key changes
+     */
+    protected readonly querySubject: Subject<string>;
+    /** last key resolved */
+    protected lastResolvedKey?: string;
+    constructor();
+    /**
+     * Calls original transform method and eventually outputs the key if debugMode (in LocalizationConfiguration) is enabled
+     * @inheritdoc
+     */
+    transform(query: string, ...args: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<O3rLocalizationTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<O3rLocalizationTranslatePipe, "o3rTranslate", true>;
+}
+
+/**
+ * Native angular CurrencyPipe taking the current lang into consideration
+ */
+declare class LocalizedCurrencyPipe extends CurrencyPipe implements PipeTransform {
+    private readonly localizationService;
+    private readonly changeDetectorRef;
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    transform(value: number | string, currencyCode?: string, display?: string | boolean, digitsInfo?: string, locale?: string): string | null;
+    transform(value: null | undefined, currencyCode?: string, display?: string | boolean, digitsInfo?: string, locale?: string): null;
+    transform(value: number | string | null | undefined, currencyCode?: string, display?: string | boolean, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedCurrencyPipe, "currency", true>;
+}
+
+/**
+ * Native angular DatePipe taking the current lang into consideration
+ */
+declare class LocalizedDatePipe extends DatePipe implements PipeTransform {
+    private readonly localizationService;
+    private readonly changeDetectorRef;
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    transform(value: Date | string | number, format?: string, timezone?: string, locale?: string): string | null;
+    transform(value: null | undefined, format?: string, timezone?: string, locale?: string): null;
+    transform(value: Date | string | number | null | undefined, format?: string, timezone?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedDatePipe, "date", true>;
+}
+
+/**
+ * Native angular DecimalPipe taking the current lang into consideration
+ */
+declare class LocalizedDecimalPipe extends DecimalPipe implements PipeTransform {
+    private readonly localizationService;
+    private readonly changeDetectorRef;
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    transform(value: number | string, digitsInfo?: string, locale?: string): string | null;
+    transform(value: null | undefined, digitsInfo?: string, locale?: string): null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedDecimalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedDecimalPipe, "number", true>;
+}
+
+/**
+ * Service for handling the text direction based on the LocalizationConfiguration
+ */
+declare class TextDirectionService implements OnDestroy {
+    private readonly translateService;
+    private readonly configuration;
+    private readonly rendererFactory;
+    private readonly directionality;
+    private subscription?;
+    private readonly renderer;
+    constructor();
+    /**
+     * Updates the dir attribute on body HTML tag.
+     * @returns a subscription that updates the dir attribute
+     */
+    onLangChangeSubscription(): Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextDirectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TextDirectionService>;
+}
+
+export { CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN, DEFAULT_LOCALIZATION_CONFIGURATION, LOCALIZATION_CONFIGURATION_TOKEN, LOCALIZATION_OVERRIDE_REDUCER_TOKEN, LOCALIZATION_OVERRIDE_STORE_NAME, Localization, LocalizationDevtoolsConsoleService, LocalizationDevtoolsMessageService, LocalizationOverrideStoreModule, LocalizationService, LocalizationTranslateDirective, LocalizedCurrencyPipe, LocalizedDatePipe, LocalizedDecimalPipe, O3rLocalizationTranslatePipe, OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS, OTTER_LOCALIZATION_DEVTOOLS_OPTIONS, OtterLocalizationDevtools, TextDirectionService, TranslationsLoader, createLocalizationConfiguration, createTranslateLoader, getDebugKey, getDefaultLocalizationOverrideReducer, localeIdNgBridge, localizationOverrideInitialState, localizationOverrideReducer, localizationOverrideReducerFeatures, localizationOverrideStorageDeserializer, localizationOverrideStorageSync, provideLocalization, provideLocalizationDevtools, selectLocalizationOverride, selectLocalizationOverrideState, setLocalizationOverride, translateLoaderProvider };
+export type { AvailableLocalizationMessageContents, DisplayLocalizationKeysContentMessage, GetTranslationValuesContentMessage, IsTranslationDeactivationEnabledContentMessage, JSONLocalization, LanguagesContentMessage, LocalizationConfiguration, LocalizationContextualizationDevtools, LocalizationDevtoolsServiceOptions, LocalizationMessageDataTypes, LocalizationMetadata, LocalizationOverrideState, LocalizationOverrideStore, LocalizationsContentMessage, ReloadLocalizationKeysContentMessage, SwitchLanguageContentMessage, Translatable, UpdateLocalizationContentMessage };
+//# sourceMappingURL=o3r-transloco.d.ts.map